[wip] cli capability parity

2026-03-06 16:58:50 -06:00
parent 48b6ca6bd7
commit 87d830f952
94 changed files with 3694 additions and 734 deletions
--- a/crates/common/tests/action_repository_tests.rs
+++ b/crates/common/tests/action_repository_tests.rs
@@ -13,6 +13,7 @@ use helpers::*;
 use serde_json::json;

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_action() {
    let pool = create_test_pool().await.unwrap();

@@ -35,6 +36,7 @@ async fn test_create_action() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_action_with_optional_fields() {
    let pool = create_test_pool().await.unwrap();

@@ -71,6 +73,7 @@ async fn test_create_action_with_optional_fields() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_action_by_id() {
    let pool = create_test_pool().await.unwrap();

@@ -95,6 +98,7 @@ async fn test_find_action_by_id() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_action_by_id_not_found() {
    let pool = create_test_pool().await.unwrap();

@@ -104,6 +108,7 @@ async fn test_find_action_by_id_not_found() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_action_by_ref() {
    let pool = create_test_pool().await.unwrap();

@@ -127,6 +132,7 @@ async fn test_find_action_by_ref() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_action_by_ref_not_found() {
    let pool = create_test_pool().await.unwrap();

@@ -138,6 +144,7 @@ async fn test_find_action_by_ref_not_found() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_list_actions() {
    let pool = create_test_pool().await.unwrap();

@@ -167,6 +174,7 @@ async fn test_list_actions() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_list_actions_empty() {
    let pool = create_test_pool().await.unwrap();

@@ -176,6 +184,7 @@ async fn test_list_actions_empty() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_action() {
    let pool = create_test_pool().await.unwrap();

@@ -211,6 +220,7 @@ async fn test_update_action() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_action_not_found() {
    let pool = create_test_pool().await.unwrap();

@@ -225,6 +235,7 @@ async fn test_update_action_not_found() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_action_partial() {
    let pool = create_test_pool().await.unwrap();

@@ -254,6 +265,7 @@ async fn test_update_action_partial() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_delete_action() {
    let pool = create_test_pool().await.unwrap();

@@ -278,6 +290,7 @@ async fn test_delete_action() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_delete_action_not_found() {
    let pool = create_test_pool().await.unwrap();

@@ -287,6 +300,7 @@ async fn test_delete_action_not_found() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_actions_cascade_delete_with_pack() {
    let pool = create_test_pool().await.unwrap();

@@ -314,6 +328,7 @@ async fn test_actions_cascade_delete_with_pack() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_action_foreign_key_constraint() {
    let pool = create_test_pool().await.unwrap();

@@ -338,6 +353,7 @@ async fn test_action_foreign_key_constraint() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_multiple_actions_same_pack() {
    let pool = create_test_pool().await.unwrap();

@@ -362,6 +378,7 @@ async fn test_multiple_actions_same_pack() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_action_unique_ref_constraint() {
    let pool = create_test_pool().await.unwrap();

@@ -386,6 +403,7 @@ async fn test_action_unique_ref_constraint() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_action_with_json_schemas() {
    let pool = create_test_pool().await.unwrap();

@@ -423,6 +441,7 @@ async fn test_action_with_json_schemas() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_action_timestamps_auto_populated() {
    let pool = create_test_pool().await.unwrap();

@@ -443,6 +462,7 @@ async fn test_action_timestamps_auto_populated() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_action_updated_changes_on_update() {
    let pool = create_test_pool().await.unwrap();

--- a/crates/common/tests/enforcement_repository_tests.rs
+++ b/crates/common/tests/enforcement_repository_tests.rs
@@ -21,6 +21,7 @@ use serde_json::json;
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_enforcement_minimal() {
    let pool = create_test_pool().await.unwrap();

@@ -93,6 +94,7 @@ async fn test_create_enforcement_minimal() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_enforcement_with_event() {
    let pool = create_test_pool().await.unwrap();

@@ -160,6 +162,7 @@ async fn test_create_enforcement_with_event() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_enforcement_with_conditions() {
    let pool = create_test_pool().await.unwrap();

@@ -225,6 +228,7 @@ async fn test_create_enforcement_with_conditions() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_enforcement_with_any_condition() {
    let pool = create_test_pool().await.unwrap();

@@ -287,6 +291,7 @@ async fn test_create_enforcement_with_any_condition() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_enforcement_without_rule_id() {
    let pool = create_test_pool().await.unwrap();

@@ -310,6 +315,7 @@ async fn test_create_enforcement_without_rule_id() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_enforcement_with_invalid_rule_fails() {
    let pool = create_test_pool().await.unwrap();

@@ -333,6 +339,7 @@ async fn test_create_enforcement_with_invalid_rule_fails() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_enforcement_with_nonexistent_event_succeeds() {
    let pool = create_test_pool().await.unwrap();

@@ -363,6 +370,7 @@ async fn test_create_enforcement_with_nonexistent_event_succeeds() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_enforcement_by_id() {
    let pool = create_test_pool().await.unwrap();

@@ -424,6 +432,7 @@ async fn test_find_enforcement_by_id() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_enforcement_by_id_not_found() {
    let pool = create_test_pool().await.unwrap();

@@ -435,6 +444,7 @@ async fn test_find_enforcement_by_id_not_found() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_get_enforcement_by_id() {
    let pool = create_test_pool().await.unwrap();

@@ -490,6 +500,7 @@ async fn test_get_enforcement_by_id() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_get_enforcement_by_id_not_found() {
    let pool = create_test_pool().await.unwrap();

@@ -504,6 +515,7 @@ async fn test_get_enforcement_by_id_not_found() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_list_enforcements_empty() {
    let pool = create_test_pool().await.unwrap();

@@ -513,6 +525,7 @@ async fn test_list_enforcements_empty() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_list_enforcements() {
    let pool = create_test_pool().await.unwrap();

@@ -584,6 +597,7 @@ async fn test_list_enforcements() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_enforcement_status() {
    let pool = create_test_pool().await.unwrap();

@@ -649,6 +663,7 @@ async fn test_update_enforcement_status() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_enforcement_status_transitions() {
    let pool = create_test_pool().await.unwrap();

@@ -727,6 +742,7 @@ async fn test_update_enforcement_status_transitions() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_enforcement_payload() {
    let pool = create_test_pool().await.unwrap();

@@ -789,6 +805,7 @@ async fn test_update_enforcement_payload() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_enforcement_both_fields() {
    let pool = create_test_pool().await.unwrap();

@@ -852,6 +869,7 @@ async fn test_update_enforcement_both_fields() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_enforcement_no_changes() {
    let pool = create_test_pool().await.unwrap();

@@ -915,6 +933,7 @@ async fn test_update_enforcement_no_changes() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_enforcement_not_found() {
    let pool = create_test_pool().await.unwrap();

@@ -935,6 +954,7 @@ async fn test_update_enforcement_not_found() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_delete_enforcement() {
    let pool = create_test_pool().await.unwrap();

@@ -995,6 +1015,7 @@ async fn test_delete_enforcement() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_delete_enforcement_not_found() {
    let pool = create_test_pool().await.unwrap();

@@ -1008,6 +1029,7 @@ async fn test_delete_enforcement_not_found() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_enforcements_by_rule() {
    let pool = create_test_pool().await.unwrap();

@@ -1100,6 +1122,7 @@ async fn test_find_enforcements_by_rule() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_enforcements_by_status() {
    let pool = create_test_pool().await.unwrap();

@@ -1189,6 +1212,7 @@ async fn test_find_enforcements_by_status() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_enforcements_by_event() {
    let pool = create_test_pool().await.unwrap();

@@ -1273,6 +1297,7 @@ async fn test_find_enforcements_by_event() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_delete_rule_sets_enforcement_rule_to_null() {
    let pool = create_test_pool().await.unwrap();

@@ -1338,6 +1363,7 @@ async fn test_delete_rule_sets_enforcement_rule_to_null() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_enforcement_resolved_at_lifecycle() {
    let pool = create_test_pool().await.unwrap();

--- a/crates/common/tests/event_repository_tests.rs
+++ b/crates/common/tests/event_repository_tests.rs
@@ -21,6 +21,7 @@ use serde_json::json;
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_event_minimal() {
    let pool = create_test_pool().await.unwrap();

@@ -60,6 +61,7 @@ async fn test_create_event_minimal() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_event_with_payload() {
    let pool = create_test_pool().await.unwrap();

@@ -101,6 +103,7 @@ async fn test_create_event_with_payload() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_event_with_config() {
    let pool = create_test_pool().await.unwrap();

@@ -136,6 +139,7 @@ async fn test_create_event_with_config() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_event_without_trigger_id() {
    let pool = create_test_pool().await.unwrap();

@@ -158,6 +162,7 @@ async fn test_create_event_without_trigger_id() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_event_with_source() {
    let pool = create_test_pool().await.unwrap();

@@ -191,6 +196,7 @@ async fn test_create_event_with_source() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_event_with_invalid_trigger_fails() {
    let pool = create_test_pool().await.unwrap();

@@ -217,6 +223,7 @@ async fn test_create_event_with_invalid_trigger_fails() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_event_by_id() {
    let pool = create_test_pool().await.unwrap();

@@ -249,6 +256,7 @@ async fn test_find_event_by_id() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_event_by_id_not_found() {
    let pool = create_test_pool().await.unwrap();

@@ -258,6 +266,7 @@ async fn test_find_event_by_id_not_found() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_get_event_by_id() {
    let pool = create_test_pool().await.unwrap();

@@ -284,6 +293,7 @@ async fn test_get_event_by_id() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_get_event_by_id_not_found() {
    let pool = create_test_pool().await.unwrap();

@@ -298,6 +308,7 @@ async fn test_get_event_by_id_not_found() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_list_events_empty() {
    let pool = create_test_pool().await.unwrap();

@@ -307,6 +318,7 @@ async fn test_list_events_empty() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_list_events() {
    let pool = create_test_pool().await.unwrap();

@@ -345,6 +357,7 @@ async fn test_list_events() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_list_events_respects_limit() {
    let pool = create_test_pool().await.unwrap();

@@ -368,6 +381,7 @@ async fn test_list_events_respects_limit() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_delete_event() {
    let pool = create_test_pool().await.unwrap();

@@ -396,6 +410,7 @@ async fn test_delete_event() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_delete_event_not_found() {
    let pool = create_test_pool().await.unwrap();

@@ -405,6 +420,7 @@ async fn test_delete_event_not_found() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_delete_event_enforcement_retains_event_id() {
    let pool = create_test_pool().await.unwrap();

@@ -480,6 +496,7 @@ async fn test_delete_event_enforcement_retains_event_id() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_events_by_trigger() {
    let pool = create_test_pool().await.unwrap();

@@ -527,6 +544,7 @@ async fn test_find_events_by_trigger() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_events_by_trigger_ref() {
    let pool = create_test_pool().await.unwrap();

@@ -561,6 +579,7 @@ async fn test_find_events_by_trigger_ref() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_events_by_trigger_ref_preserves_after_trigger_deletion() {
    let pool = create_test_pool().await.unwrap();

@@ -602,6 +621,7 @@ async fn test_find_events_by_trigger_ref_preserves_after_trigger_deletion() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_event_created_timestamp_auto_set() {
    let pool = create_test_pool().await.unwrap();

--- a/crates/common/tests/execution_repository_tests.rs
+++ b/crates/common/tests/execution_repository_tests.rs
@@ -20,6 +20,7 @@ use serde_json::json;
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_execution_basic() {
    let pool = create_test_pool().await.unwrap();

@@ -61,6 +62,7 @@ async fn test_create_execution_basic() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_execution_without_action() {
    let pool = create_test_pool().await.unwrap();

@@ -86,6 +88,7 @@ async fn test_create_execution_without_action() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_execution_with_all_fields() {
    let pool = create_test_pool().await.unwrap();

@@ -120,6 +123,7 @@ async fn test_create_execution_with_all_fields() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_execution_with_parent() {
    let pool = create_test_pool().await.unwrap();

@@ -177,6 +181,7 @@ async fn test_create_execution_with_parent() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_execution_by_id() {
    let pool = create_test_pool().await.unwrap();

@@ -216,6 +221,7 @@ async fn test_find_execution_by_id() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_execution_by_id_not_found() {
    let pool = create_test_pool().await.unwrap();

@@ -227,6 +233,7 @@ async fn test_find_execution_by_id_not_found() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_list_executions() {
    let pool = create_test_pool().await.unwrap();

@@ -270,6 +277,7 @@ async fn test_list_executions() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_list_executions_ordered_by_created_desc() {
    let pool = create_test_pool().await.unwrap();

@@ -324,6 +332,7 @@ async fn test_list_executions_ordered_by_created_desc() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_execution_status() {
    let pool = create_test_pool().await.unwrap();

@@ -368,6 +377,7 @@ async fn test_update_execution_status() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_execution_result() {
    let pool = create_test_pool().await.unwrap();

@@ -413,6 +423,7 @@ async fn test_update_execution_result() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_execution_executor() {
    let pool = create_test_pool().await.unwrap();

@@ -456,6 +467,7 @@ async fn test_update_execution_executor() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_execution_status_transitions() {
    let pool = create_test_pool().await.unwrap();

@@ -546,6 +558,7 @@ async fn test_update_execution_status_transitions() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_execution_failed_status() {
    let pool = create_test_pool().await.unwrap();

@@ -590,6 +603,7 @@ async fn test_update_execution_failed_status() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_execution_no_changes() {
    let pool = create_test_pool().await.unwrap();

@@ -633,6 +647,7 @@ async fn test_update_execution_no_changes() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_delete_execution() {
    let pool = create_test_pool().await.unwrap();

@@ -675,6 +690,7 @@ async fn test_delete_execution() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_delete_execution_not_found() {
    let pool = create_test_pool().await.unwrap();

@@ -688,6 +704,7 @@ async fn test_delete_execution_not_found() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_executions_by_status() {
    let pool = create_test_pool().await.unwrap();

@@ -743,6 +760,7 @@ async fn test_find_executions_by_status() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_executions_by_enforcement() {
    let pool = create_test_pool().await.unwrap();

@@ -804,6 +822,7 @@ async fn test_find_executions_by_enforcement() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_parent_child_execution_hierarchy() {
    let pool = create_test_pool().await.unwrap();

@@ -867,6 +886,7 @@ async fn test_parent_child_execution_hierarchy() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_nested_execution_hierarchy() {
    let pool = create_test_pool().await.unwrap();

@@ -945,6 +965,7 @@ async fn test_nested_execution_hierarchy() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_execution_timestamps() {
    let pool = create_test_pool().await.unwrap();

@@ -1000,6 +1021,7 @@ async fn test_execution_timestamps() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_execution_config_json() {
    let pool = create_test_pool().await.unwrap();

@@ -1047,6 +1069,7 @@ async fn test_execution_config_json() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_execution_result_json() {
    let pool = create_test_pool().await.unwrap();

--- a/crates/common/tests/helpers.rs
+++ b/crates/common/tests/helpers.rs
@@ -1116,7 +1116,7 @@ pub struct KeyFixture {
    pub name: String,
    pub encrypted: bool,
    pub encryption_key_hash: Option<String>,
-    pub value: String,
+    pub value: serde_json::Value,
 }

 impl KeyFixture {
@@ -1136,7 +1136,7 @@ impl KeyFixture {
            name: name.to_string(),
            encrypted: false,
            encryption_key_hash: None,
-            value: value.to_string(),
+            value: serde_json::json!(value),
        }
    }

@@ -1157,7 +1157,7 @@ impl KeyFixture {
            name: unique_name,
            encrypted: false,
            encryption_key_hash: None,
-            value: value.to_string(),
+            value: serde_json::json!(value),
        }
    }

@@ -1177,7 +1177,7 @@ impl KeyFixture {
            name: name.to_string(),
            encrypted: false,
            encryption_key_hash: None,
-            value: value.to_string(),
+            value: serde_json::json!(value),
        }
    }

@@ -1198,7 +1198,7 @@ impl KeyFixture {
            name: unique_name,
            encrypted: false,
            encryption_key_hash: None,
-            value: value.to_string(),
+            value: serde_json::json!(value),
        }
    }

@@ -1218,7 +1218,7 @@ impl KeyFixture {
            name: name.to_string(),
            encrypted: false,
            encryption_key_hash: None,
-            value: value.to_string(),
+            value: serde_json::json!(value),
        }
    }

@@ -1239,7 +1239,7 @@ impl KeyFixture {
            name: unique_name,
            encrypted: false,
            encryption_key_hash: None,
-            value: value.to_string(),
+            value: serde_json::json!(value),
        }
    }

@@ -1254,7 +1254,7 @@ impl KeyFixture {
    }

    pub fn with_value(mut self, value: &str) -> Self {
-        self.value = value.to_string();
+        self.value = serde_json::json!(value);
        self
    }

--- a/crates/common/tests/identity_repository_tests.rs
+++ b/crates/common/tests/identity_repository_tests.rs
@@ -16,6 +16,7 @@ use helpers::*;
 use serde_json::json;

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_identity() {
    let pool = create_test_pool().await.unwrap();

@@ -38,6 +39,7 @@ async fn test_create_identity() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_identity_minimal() {
    let pool = create_test_pool().await.unwrap();

@@ -56,6 +58,7 @@ async fn test_create_identity_minimal() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_identity_duplicate_login() {
    let pool = create_test_pool().await.unwrap();

@@ -92,6 +95,7 @@ async fn test_create_identity_duplicate_login() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_identity_by_id() {
    let pool = create_test_pool().await.unwrap();

@@ -116,6 +120,7 @@ async fn test_find_identity_by_id() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_identity_by_id_not_found() {
    let pool = create_test_pool().await.unwrap();

@@ -125,6 +130,7 @@ async fn test_find_identity_by_id_not_found() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_identity_by_login() {
    let pool = create_test_pool().await.unwrap();

@@ -148,6 +154,7 @@ async fn test_find_identity_by_login() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_identity_by_login_not_found() {
    let pool = create_test_pool().await.unwrap();

@@ -159,6 +166,7 @@ async fn test_find_identity_by_login_not_found() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_list_identities() {
    let pool = create_test_pool().await.unwrap();

@@ -190,6 +198,7 @@ async fn test_list_identities() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_identity() {
    let pool = create_test_pool().await.unwrap();

@@ -225,6 +234,7 @@ async fn test_update_identity() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_identity_partial() {
    let pool = create_test_pool().await.unwrap();

@@ -256,6 +266,7 @@ async fn test_update_identity_partial() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_identity_not_found() {
    let pool = create_test_pool().await.unwrap();

@@ -279,6 +290,7 @@ async fn test_update_identity_not_found() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_delete_identity() {
    let pool = create_test_pool().await.unwrap();

@@ -311,6 +323,7 @@ async fn test_delete_identity() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_delete_identity_not_found() {
    let pool = create_test_pool().await.unwrap();

@@ -320,6 +333,7 @@ async fn test_delete_identity_not_found() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_identity_timestamps_auto_populated() {
    let pool = create_test_pool().await.unwrap();

@@ -344,6 +358,7 @@ async fn test_identity_timestamps_auto_populated() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_identity_updated_changes_on_update() {
    let pool = create_test_pool().await.unwrap();

@@ -379,6 +394,7 @@ async fn test_identity_updated_changes_on_update() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_identity_with_complex_attributes() {
    let pool = create_test_pool().await.unwrap();

@@ -419,6 +435,7 @@ async fn test_identity_with_complex_attributes() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_identity_login_case_sensitive() {
    let pool = create_test_pool().await.unwrap();

--- a/crates/common/tests/inquiry_repository_tests.rs
+++ b/crates/common/tests/inquiry_repository_tests.rs
@@ -22,6 +22,7 @@ use serde_json::json;
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_inquiry_minimal() {
    let pool = create_test_pool().await.unwrap();

@@ -83,6 +84,7 @@ async fn test_create_inquiry_minimal() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_inquiry_with_response_schema() {
    let pool = create_test_pool().await.unwrap();

@@ -140,6 +142,7 @@ async fn test_create_inquiry_with_response_schema() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_inquiry_with_timeout() {
    let pool = create_test_pool().await.unwrap();

@@ -193,6 +196,7 @@ async fn test_create_inquiry_with_timeout() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_inquiry_with_assigned_user() {
    let pool = create_test_pool().await.unwrap();

@@ -255,6 +259,7 @@ async fn test_create_inquiry_with_assigned_user() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_inquiry_with_invalid_execution_fails() {
    let pool = create_test_pool().await.unwrap();

@@ -280,6 +285,7 @@ async fn test_create_inquiry_with_invalid_execution_fails() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_inquiry_by_id() {
    let pool = create_test_pool().await.unwrap();

@@ -331,6 +337,7 @@ async fn test_find_inquiry_by_id() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_inquiry_by_id_not_found() {
    let pool = create_test_pool().await.unwrap();

@@ -340,6 +347,7 @@ async fn test_find_inquiry_by_id_not_found() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_get_inquiry_by_id() {
    let pool = create_test_pool().await.unwrap();

@@ -385,6 +393,7 @@ async fn test_get_inquiry_by_id() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_get_inquiry_by_id_not_found() {
    let pool = create_test_pool().await.unwrap();

@@ -399,6 +408,7 @@ async fn test_get_inquiry_by_id_not_found() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_list_inquiries_empty() {
    let pool = create_test_pool().await.unwrap();

@@ -408,6 +418,7 @@ async fn test_list_inquiries_empty() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_list_inquiries() {
    let pool = create_test_pool().await.unwrap();

@@ -468,6 +479,7 @@ async fn test_list_inquiries() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_inquiry_status() {
    let pool = create_test_pool().await.unwrap();

@@ -523,6 +535,7 @@ async fn test_update_inquiry_status() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_inquiry_status_transitions() {
    let pool = create_test_pool().await.unwrap();

@@ -607,6 +620,7 @@ async fn test_update_inquiry_status_transitions() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_inquiry_response() {
    let pool = create_test_pool().await.unwrap();

@@ -664,6 +678,7 @@ async fn test_update_inquiry_response() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_inquiry_with_response_and_status() {
    let pool = create_test_pool().await.unwrap();

@@ -721,6 +736,7 @@ async fn test_update_inquiry_with_response_and_status() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_inquiry_assignment() {
    let pool = create_test_pool().await.unwrap();

@@ -787,6 +803,7 @@ async fn test_update_inquiry_assignment() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_inquiry_no_changes() {
    let pool = create_test_pool().await.unwrap();

@@ -841,6 +858,7 @@ async fn test_update_inquiry_no_changes() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_inquiry_not_found() {
    let pool = create_test_pool().await.unwrap();

@@ -862,6 +880,7 @@ async fn test_update_inquiry_not_found() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_delete_inquiry() {
    let pool = create_test_pool().await.unwrap();

@@ -911,6 +930,7 @@ async fn test_delete_inquiry() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_delete_inquiry_not_found() {
    let pool = create_test_pool().await.unwrap();

@@ -920,6 +940,7 @@ async fn test_delete_inquiry_not_found() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_delete_execution_cascades_to_inquiries() {
    let pool = create_test_pool().await.unwrap();

@@ -986,6 +1007,7 @@ async fn test_delete_execution_cascades_to_inquiries() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_inquiries_by_status() {
    let pool = create_test_pool().await.unwrap();

@@ -1064,6 +1086,7 @@ async fn test_find_inquiries_by_status() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_inquiries_by_execution() {
    let pool = create_test_pool().await.unwrap();

@@ -1145,6 +1168,7 @@ async fn test_find_inquiries_by_execution() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_inquiry_timestamps_auto_managed() {
    let pool = create_test_pool().await.unwrap();

@@ -1211,6 +1235,7 @@ async fn test_inquiry_timestamps_auto_managed() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_inquiry_complex_response_schema() {
    let pool = create_test_pool().await.unwrap();

--- a/crates/common/tests/key_repository_tests.rs
+++ b/crates/common/tests/key_repository_tests.rs
@@ -20,6 +20,7 @@ use helpers::*;
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_key_system_owner() {
    let pool = create_test_pool().await.unwrap();

@@ -36,12 +37,13 @@ async fn test_create_key_system_owner() {
    assert_eq!(key.owner_action, None);
    assert_eq!(key.owner_sensor, None);
    assert!(!key.encrypted);
-    assert_eq!(key.value, "test_value");
+    assert_eq!(key.value, serde_json::json!("test_value"));
    assert!(key.created.timestamp() > 0);
    assert!(key.updated.timestamp() > 0);
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_key_system_encrypted() {
    let pool = create_test_pool().await.unwrap();

@@ -61,6 +63,7 @@ async fn test_create_key_system_encrypted() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_key_identity_owner() {
    let pool = create_test_pool().await.unwrap();

@@ -79,7 +82,7 @@ async fn test_create_key_identity_owner() {
    assert_eq!(key.owner, Some(identity.id.to_string()));
    assert_eq!(key.owner_identity, Some(identity.id));
    assert_eq!(key.owner_pack, None);
-    assert_eq!(key.value, "secret_token");
+    assert_eq!(key.value, serde_json::json!("secret_token"));
 }

 // ============================================================================
@@ -87,6 +90,7 @@ async fn test_create_key_identity_owner() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_key_pack_owner() {
    let pool = create_test_pool().await.unwrap();

@@ -104,7 +108,7 @@ async fn test_create_key_pack_owner() {
    assert_eq!(key.owner, Some(pack.id.to_string()));
    assert_eq!(key.owner_pack, Some(pack.id));
    assert_eq!(key.owner_pack_ref, Some(pack.r#ref.clone()));
-    assert_eq!(key.value, "config_value");
+    assert_eq!(key.value, serde_json::json!("config_value"));
 }

 // ============================================================================
@@ -112,6 +116,7 @@ async fn test_create_key_pack_owner() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_key_duplicate_ref_fails() {
    let pool = create_test_pool().await.unwrap();

@@ -132,7 +137,7 @@ async fn test_create_key_duplicate_ref_fails() {
        name: key_ref.clone(),
        encrypted: false,
        encryption_key_hash: None,
-        value: "value1".to_string(),
+        value: serde_json::json!("value1"),
    };

    KeyRepository::create(&pool, input.clone()).await.unwrap();
@@ -143,6 +148,7 @@ async fn test_create_key_duplicate_ref_fails() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_key_system_with_owner_fields_fails() {
    let pool = create_test_pool().await.unwrap();

@@ -167,7 +173,7 @@ async fn test_create_key_system_with_owner_fields_fails() {
        name: "invalid".to_string(),
        encrypted: false,
        encryption_key_hash: None,
-        value: "value".to_string(),
+        value: serde_json::json!("value"),
    };

    let result = KeyRepository::create(&pool, input).await;
@@ -175,6 +181,7 @@ async fn test_create_key_system_with_owner_fields_fails() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_key_identity_without_owner_id_fails() {
    let pool = create_test_pool().await.unwrap();

@@ -193,7 +200,7 @@ async fn test_create_key_identity_without_owner_id_fails() {
        name: "invalid".to_string(),
        encrypted: false,
        encryption_key_hash: None,
-        value: "value".to_string(),
+        value: serde_json::json!("value"),
    };

    let result = KeyRepository::create(&pool, input).await;
@@ -201,6 +208,7 @@ async fn test_create_key_identity_without_owner_id_fails() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_key_multiple_owners_fails() {
    let pool = create_test_pool().await.unwrap();

@@ -229,7 +237,7 @@ async fn test_create_key_multiple_owners_fails() {
        name: "invalid".to_string(),
        encrypted: false,
        encryption_key_hash: None,
-        value: "value".to_string(),
+        value: serde_json::json!("value"),
    };

    let result = KeyRepository::create(&pool, input).await;
@@ -237,6 +245,7 @@ async fn test_create_key_multiple_owners_fails() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_key_invalid_ref_format_fails() {
    let pool = create_test_pool().await.unwrap();

@@ -255,7 +264,7 @@ async fn test_create_key_invalid_ref_format_fails() {
        name: "uppercase".to_string(),
        encrypted: false,
        encryption_key_hash: None,
-        value: "value".to_string(),
+        value: serde_json::json!("value"),
    };

    let result = KeyRepository::create(&pool, input).await;
@@ -267,6 +276,7 @@ async fn test_create_key_invalid_ref_format_fails() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_by_id_exists() {
    let pool = create_test_pool().await.unwrap();

@@ -285,6 +295,7 @@ async fn test_find_by_id_exists() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_by_id_not_exists() {
    let pool = create_test_pool().await.unwrap();

@@ -293,6 +304,7 @@ async fn test_find_by_id_not_exists() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_get_by_id_exists() {
    let pool = create_test_pool().await.unwrap();

@@ -308,6 +320,7 @@ async fn test_get_by_id_exists() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_get_by_id_not_exists_fails() {
    let pool = create_test_pool().await.unwrap();

@@ -317,6 +330,7 @@ async fn test_get_by_id_not_exists_fails() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_by_ref_exists() {
    let pool = create_test_pool().await.unwrap();

@@ -334,6 +348,7 @@ async fn test_find_by_ref_exists() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_by_ref_not_exists() {
    let pool = create_test_pool().await.unwrap();

@@ -344,6 +359,7 @@ async fn test_find_by_ref_not_exists() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_list_all_keys() {
    let pool = create_test_pool().await.unwrap();

@@ -373,6 +389,7 @@ async fn test_list_all_keys() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_value() {
    let pool = create_test_pool().await.unwrap();

@@ -387,17 +404,18 @@ async fn test_update_value() {
    tokio::time::sleep(tokio::time::Duration::from_millis(10)).await;

    let input = UpdateKeyInput {
-        value: Some("new_value".to_string()),
+        value: Some(serde_json::json!("new_value")),
        ..Default::default()
    };

    let updated = KeyRepository::update(&pool, key.id, input).await.unwrap();

-    assert_eq!(updated.value, "new_value");
+    assert_eq!(updated.value, serde_json::json!("new_value"));
    assert!(updated.updated > original_updated);
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_name() {
    let pool = create_test_pool().await.unwrap();

@@ -419,6 +437,7 @@ async fn test_update_name() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_encrypted_status() {
    let pool = create_test_pool().await.unwrap();

@@ -432,7 +451,7 @@ async fn test_update_encrypted_status() {
    let input = UpdateKeyInput {
        encrypted: Some(true),
        encryption_key_hash: Some("sha256:xyz789".to_string()),
-        value: Some("encrypted_value".to_string()),
+        value: Some(serde_json::json!("encrypted_value")),
        ..Default::default()
    };

@@ -443,10 +462,11 @@ async fn test_update_encrypted_status() {
        updated.encryption_key_hash,
        Some("sha256:xyz789".to_string())
    );
-    assert_eq!(updated.value, "encrypted_value");
+    assert_eq!(updated.value, serde_json::json!("encrypted_value"));
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_multiple_fields() {
    let pool = create_test_pool().await.unwrap();

@@ -459,7 +479,7 @@ async fn test_update_multiple_fields() {
    let new_name = format!("updated_name_{}", unique_test_id());
    let input = UpdateKeyInput {
        name: Some(new_name.clone()),
-        value: Some("updated_value".to_string()),
+        value: Some(serde_json::json!("updated_value")),
        encrypted: Some(true),
        encryption_key_hash: Some("hash123".to_string()),
    };
@@ -467,12 +487,13 @@ async fn test_update_multiple_fields() {
    let updated = KeyRepository::update(&pool, key.id, input).await.unwrap();

    assert_eq!(updated.name, new_name);
-    assert_eq!(updated.value, "updated_value");
+    assert_eq!(updated.value, serde_json::json!("updated_value"));
    assert!(updated.encrypted);
    assert_eq!(updated.encryption_key_hash, Some("hash123".to_string()));
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_no_changes() {
    let pool = create_test_pool().await.unwrap();

@@ -495,11 +516,12 @@ async fn test_update_no_changes() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_nonexistent_key_fails() {
    let pool = create_test_pool().await.unwrap();

    let input = UpdateKeyInput {
-        value: Some("new_value".to_string()),
+        value: Some(serde_json::json!("new_value")),
        ..Default::default()
    };

@@ -512,6 +534,7 @@ async fn test_update_nonexistent_key_fails() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_delete_existing_key() {
    let pool = create_test_pool().await.unwrap();

@@ -529,6 +552,7 @@ async fn test_delete_existing_key() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_delete_nonexistent_key() {
    let pool = create_test_pool().await.unwrap();

@@ -537,6 +561,7 @@ async fn test_delete_nonexistent_key() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_delete_key_when_identity_deleted() {
    let pool = create_test_pool().await.unwrap();

@@ -563,6 +588,7 @@ async fn test_delete_key_when_identity_deleted() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_delete_key_when_pack_deleted() {
    let pool = create_test_pool().await.unwrap();

@@ -593,6 +619,7 @@ async fn test_delete_key_when_pack_deleted() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_by_owner_type_system() {
    let pool = create_test_pool().await.unwrap();

@@ -616,6 +643,7 @@ async fn test_find_by_owner_type_system() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_by_owner_type_identity() {
    let pool = create_test_pool().await.unwrap();

@@ -650,6 +678,7 @@ async fn test_find_by_owner_type_identity() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_by_owner_type_pack() {
    let pool = create_test_pool().await.unwrap();

@@ -683,6 +712,7 @@ async fn test_find_by_owner_type_pack() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_created_timestamp_set_automatically() {
    let pool = create_test_pool().await.unwrap();

@@ -701,6 +731,7 @@ async fn test_created_timestamp_set_automatically() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_updated_timestamp_changes_on_update() {
    let pool = create_test_pool().await.unwrap();

@@ -715,7 +746,7 @@ async fn test_updated_timestamp_changes_on_update() {
    tokio::time::sleep(tokio::time::Duration::from_millis(10)).await;

    let input = UpdateKeyInput {
-        value: Some("new_value".to_string()),
+        value: Some(serde_json::json!("new_value")),
        ..Default::default()
    };

@@ -726,6 +757,7 @@ async fn test_updated_timestamp_changes_on_update() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_updated_timestamp_unchanged_on_read() {
    let pool = create_test_pool().await.unwrap();

@@ -753,6 +785,7 @@ async fn test_updated_timestamp_unchanged_on_read() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_key_encrypted_flag() {
    let pool = create_test_pool().await.unwrap();

@@ -779,6 +812,7 @@ async fn test_key_encrypted_flag() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_encryption_status() {
    let pool = create_test_pool().await.unwrap();

@@ -794,7 +828,7 @@ async fn test_update_encryption_status() {
    let input = UpdateKeyInput {
        encrypted: Some(true),
        encryption_key_hash: Some("sha256:newkey".to_string()),
-        value: Some("encrypted_value".to_string()),
+        value: Some(serde_json::json!("encrypted_value")),
        ..Default::default()
    };

@@ -805,20 +839,20 @@ async fn test_update_encryption_status() {
        encrypted.encryption_key_hash,
        Some("sha256:newkey".to_string())
    );
-    assert_eq!(encrypted.value, "encrypted_value");
+    assert_eq!(encrypted.value, serde_json::json!("encrypted_value"));

    // Decrypt it
    let input = UpdateKeyInput {
        encrypted: Some(false),
        encryption_key_hash: None,
-        value: Some("plain_value".to_string()),
+        value: Some(serde_json::json!("plain_value")),
        ..Default::default()
    };

    let decrypted = KeyRepository::update(&pool, key.id, input).await.unwrap();

    assert!(!decrypted.encrypted);
-    assert_eq!(decrypted.value, "plain_value");
+    assert_eq!(decrypted.value, serde_json::json!("plain_value"));
 }

 // ============================================================================
@@ -826,6 +860,7 @@ async fn test_update_encryption_status() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_multiple_keys_same_pack_different_names() {
    let pool = create_test_pool().await.unwrap();

@@ -851,6 +886,7 @@ async fn test_multiple_keys_same_pack_different_names() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_same_key_name_different_owners() {
    let pool = create_test_pool().await.unwrap();

--- a/crates/common/tests/migration_tests.rs
+++ b/crates/common/tests/migration_tests.rs
@@ -9,6 +9,7 @@ use helpers::*;
 use sqlx::Row;

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_migrations_applied() {
    let pool = create_test_pool().await.unwrap();

@@ -41,6 +42,7 @@ async fn test_migrations_applied() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_pack_table_exists() {
    let pool = create_test_pool().await.unwrap();

@@ -62,6 +64,7 @@ async fn test_pack_table_exists() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_action_table_exists() {
    let pool = create_test_pool().await.unwrap();

@@ -83,6 +86,7 @@ async fn test_action_table_exists() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_trigger_table_exists() {
    let pool = create_test_pool().await.unwrap();

@@ -104,6 +108,7 @@ async fn test_trigger_table_exists() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_sensor_table_exists() {
    let pool = create_test_pool().await.unwrap();

@@ -125,6 +130,7 @@ async fn test_sensor_table_exists() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_rule_table_exists() {
    let pool = create_test_pool().await.unwrap();

@@ -146,6 +152,7 @@ async fn test_rule_table_exists() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_execution_table_exists() {
    let pool = create_test_pool().await.unwrap();

@@ -167,6 +174,7 @@ async fn test_execution_table_exists() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_event_table_exists() {
    let pool = create_test_pool().await.unwrap();

@@ -188,6 +196,7 @@ async fn test_event_table_exists() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_enforcement_table_exists() {
    let pool = create_test_pool().await.unwrap();

@@ -209,6 +218,7 @@ async fn test_enforcement_table_exists() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_inquiry_table_exists() {
    let pool = create_test_pool().await.unwrap();

@@ -230,6 +240,7 @@ async fn test_inquiry_table_exists() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_identity_table_exists() {
    let pool = create_test_pool().await.unwrap();

@@ -251,6 +262,7 @@ async fn test_identity_table_exists() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_key_table_exists() {
    let pool = create_test_pool().await.unwrap();

@@ -272,6 +284,7 @@ async fn test_key_table_exists() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_notification_table_exists() {
    let pool = create_test_pool().await.unwrap();

@@ -293,6 +306,7 @@ async fn test_notification_table_exists() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_runtime_table_exists() {
    let pool = create_test_pool().await.unwrap();

@@ -314,6 +328,7 @@ async fn test_runtime_table_exists() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_worker_table_exists() {
    let pool = create_test_pool().await.unwrap();

@@ -335,6 +350,7 @@ async fn test_worker_table_exists() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_pack_columns() {
    let pool = create_test_pool().await.unwrap();

@@ -381,6 +397,7 @@ async fn test_pack_columns() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_action_columns() {
    let pool = create_test_pool().await.unwrap();

@@ -425,6 +442,7 @@ async fn test_action_columns() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_timestamps_auto_populated() {
    let pool = create_test_pool().await.unwrap();
    clean_database(&pool).await.unwrap();
@@ -443,6 +461,7 @@ async fn test_timestamps_auto_populated() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_json_column_storage() {
    let pool = create_test_pool().await.unwrap();
    clean_database(&pool).await.unwrap();
@@ -461,6 +480,7 @@ async fn test_json_column_storage() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_array_column_storage() {
    let pool = create_test_pool().await.unwrap();
    clean_database(&pool).await.unwrap();
@@ -484,6 +504,7 @@ async fn test_array_column_storage() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_unique_constraints() {
    let pool = create_test_pool().await.unwrap();
    clean_database(&pool).await.unwrap();
@@ -498,6 +519,7 @@ async fn test_unique_constraints() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_foreign_key_constraints() {
    let pool = create_test_pool().await.unwrap();
    clean_database(&pool).await.unwrap();
@@ -525,6 +547,7 @@ async fn test_foreign_key_constraints() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_enum_types_exist() {
    let pool = create_test_pool().await.unwrap();

--- a/crates/common/tests/notification_repository_tests.rs
+++ b/crates/common/tests/notification_repository_tests.rs
@@ -89,6 +89,7 @@ impl NotificationFixture {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_notification_minimal() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = NotificationFixture::new(pool.clone());
@@ -119,6 +120,7 @@ async fn test_create_notification_minimal() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_notification_with_content() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = NotificationFixture::new(pool.clone());
@@ -152,6 +154,7 @@ async fn test_create_notification_with_content() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_notification_all_states() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = NotificationFixture::new(pool.clone());
@@ -185,6 +188,7 @@ async fn test_create_notification_all_states() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_notification_by_id() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = NotificationFixture::new(pool.clone());
@@ -205,6 +209,7 @@ async fn test_find_notification_by_id() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_notification_by_id_not_found() {
    let pool = create_test_pool().await.expect("Failed to create pool");

@@ -216,6 +221,7 @@ async fn test_find_notification_by_id_not_found() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_notification_state() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = NotificationFixture::new(pool.clone());
@@ -238,6 +244,7 @@ async fn test_update_notification_state() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_notification_content() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = NotificationFixture::new(pool.clone());
@@ -265,6 +272,7 @@ async fn test_update_notification_content() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_notification_state_and_content() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = NotificationFixture::new(pool.clone());
@@ -289,6 +297,7 @@ async fn test_update_notification_state_and_content() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_notification_no_changes() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = NotificationFixture::new(pool.clone());
@@ -310,6 +319,7 @@ async fn test_update_notification_no_changes() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_notification_timestamps() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = NotificationFixture::new(pool.clone());
@@ -337,6 +347,7 @@ async fn test_update_notification_timestamps() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_delete_notification() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = NotificationFixture::new(pool.clone());
@@ -357,6 +368,7 @@ async fn test_delete_notification() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_delete_notification_not_found() {
    let pool = create_test_pool().await.expect("Failed to create pool");

@@ -368,6 +380,7 @@ async fn test_delete_notification_not_found() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_list_notifications() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = NotificationFixture::new(pool.clone());
@@ -408,6 +421,7 @@ async fn test_list_notifications() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_by_state() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = NotificationFixture::new(pool.clone());
@@ -467,6 +481,7 @@ async fn test_find_by_state() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_by_state_empty() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = NotificationFixture::new(pool.clone());
@@ -485,6 +500,7 @@ async fn test_find_by_state_empty() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_by_channel() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = NotificationFixture::new(pool.clone());
@@ -541,6 +557,7 @@ async fn test_find_by_channel() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_by_channel_empty() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = NotificationFixture::new(pool.clone());
@@ -555,6 +572,7 @@ async fn test_find_by_channel_empty() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_notification_with_complex_content() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = NotificationFixture::new(pool.clone());
@@ -589,6 +607,7 @@ async fn test_notification_with_complex_content() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_notification_entity_types() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = NotificationFixture::new(pool.clone());
@@ -615,6 +634,7 @@ async fn test_notification_entity_types() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_notification_activity_types() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = NotificationFixture::new(pool.clone());
@@ -641,6 +661,7 @@ async fn test_notification_activity_types() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_notification_ordering_by_created() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = NotificationFixture::new(pool.clone());
@@ -702,6 +723,7 @@ async fn test_notification_ordering_by_created() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_notification_timestamps_auto_set() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = NotificationFixture::new(pool.clone());
@@ -724,6 +746,7 @@ async fn test_notification_timestamps_auto_set() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_multiple_notifications_same_entity() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = NotificationFixture::new(pool.clone());
@@ -776,6 +799,7 @@ async fn test_multiple_notifications_same_entity() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_notification_content_null_vs_empty_json() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = NotificationFixture::new(pool.clone());
@@ -794,6 +818,7 @@ async fn test_notification_content_null_vs_empty_json() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_notification_content_to_null() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = NotificationFixture::new(pool.clone());
@@ -817,6 +842,7 @@ async fn test_update_notification_content_to_null() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_notification_state_transition_workflow() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = NotificationFixture::new(pool.clone());
@@ -867,6 +893,7 @@ async fn test_notification_state_transition_workflow() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_notification_list_limit() {
    let pool = create_test_pool().await.expect("Failed to create pool");

@@ -879,6 +906,7 @@ async fn test_notification_list_limit() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_notification_with_special_characters() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = NotificationFixture::new(pool.clone());
@@ -911,6 +939,7 @@ async fn test_notification_with_special_characters() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_notification_with_long_strings() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = NotificationFixture::new(pool.clone());
@@ -944,6 +973,7 @@ async fn test_notification_with_long_strings() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_by_state_with_multiple_states() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = NotificationFixture::new(pool.clone());
@@ -1018,6 +1048,7 @@ async fn test_find_by_state_with_multiple_states() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_notification_content_array() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = NotificationFixture::new(pool.clone());
@@ -1034,6 +1065,7 @@ async fn test_notification_content_array() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_notification_content_string_value() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = NotificationFixture::new(pool.clone());
@@ -1046,6 +1078,7 @@ async fn test_notification_content_string_value() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_notification_content_number_value() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = NotificationFixture::new(pool.clone());
@@ -1058,6 +1091,7 @@ async fn test_notification_content_number_value() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_notification_parallel_creation() {
    let pool = create_test_pool().await.expect("Failed to create pool");

@@ -1096,6 +1130,7 @@ async fn test_notification_parallel_creation() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_notification_channel_case_sensitive() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = NotificationFixture::new(pool.clone());
@@ -1143,6 +1178,7 @@ async fn test_notification_channel_case_sensitive() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_notification_entity_type_variations() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = NotificationFixture::new(pool.clone());
@@ -1181,6 +1217,7 @@ async fn test_notification_entity_type_variations() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_notification_update_same_state() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = NotificationFixture::new(pool.clone());
@@ -1207,6 +1244,7 @@ async fn test_notification_update_same_state() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_notification_multiple_updates() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = NotificationFixture::new(pool.clone());
@@ -1230,6 +1268,7 @@ async fn test_notification_multiple_updates() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_notification_get_by_id_alias() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = NotificationFixture::new(pool.clone());
--- a/crates/common/tests/pack_repository_tests.rs
+++ b/crates/common/tests/pack_repository_tests.rs
@@ -12,6 +12,7 @@ use helpers::*;
 use serde_json::json;

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_pack() {
    let pool = create_test_pool().await.unwrap();

@@ -32,6 +33,7 @@ async fn test_create_pack() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_pack_duplicate_ref() {
    let pool = create_test_pool().await.unwrap();

@@ -48,6 +50,7 @@ async fn test_create_pack_duplicate_ref() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_pack_with_tags() {
    let pool = create_test_pool().await.unwrap();

@@ -63,6 +66,7 @@ async fn test_create_pack_with_tags() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_pack_standard() {
    let pool = create_test_pool().await.unwrap();

@@ -76,6 +80,7 @@ async fn test_create_pack_standard() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_pack_by_id() {
    let pool = create_test_pool().await.unwrap();

@@ -95,6 +100,7 @@ async fn test_find_pack_by_id() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_pack_by_id_not_found() {
    let pool = create_test_pool().await.unwrap();

@@ -104,6 +110,7 @@ async fn test_find_pack_by_id_not_found() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_pack_by_ref() {
    let pool = create_test_pool().await.unwrap();

@@ -122,6 +129,7 @@ async fn test_find_pack_by_ref() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_pack_by_ref_not_found() {
    let pool = create_test_pool().await.unwrap();

@@ -133,6 +141,7 @@ async fn test_find_pack_by_ref_not_found() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_list_packs() {
    let pool = create_test_pool().await.unwrap();

@@ -163,6 +172,7 @@ async fn test_list_packs() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_list_packs_with_pagination() {
    let pool = create_test_pool().await.unwrap();

@@ -190,6 +200,7 @@ async fn test_list_packs_with_pagination() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_pack() {
    let pool = create_test_pool().await.unwrap();

@@ -219,6 +230,7 @@ async fn test_update_pack() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_pack_partial() {
    let pool = create_test_pool().await.unwrap();

@@ -246,6 +258,7 @@ async fn test_update_pack_partial() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_pack_not_found() {
    let pool = create_test_pool().await.unwrap();

@@ -261,6 +274,7 @@ async fn test_update_pack_not_found() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_pack_tags() {
    let pool = create_test_pool().await.unwrap();

@@ -286,6 +300,7 @@ async fn test_update_pack_tags() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_delete_pack() {
    let pool = create_test_pool().await.unwrap();

@@ -307,6 +322,7 @@ async fn test_delete_pack() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_delete_pack_not_found() {
    let pool = create_test_pool().await.unwrap();

@@ -348,6 +364,7 @@ async fn test_delete_pack_not_found() {
 // }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_count_packs() {
    let pool = create_test_pool().await.unwrap();

@@ -374,6 +391,7 @@ async fn test_count_packs() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_pack_transaction_commit() {
    let pool = create_test_pool().await.unwrap();

@@ -412,6 +430,7 @@ async fn test_pack_transaction_commit() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_pack_transaction_rollback() {
    let pool = create_test_pool().await.unwrap();

@@ -446,6 +465,7 @@ async fn test_pack_transaction_rollback() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_pack_invalid_ref_format() {
    let pool = create_test_pool().await.unwrap();

@@ -471,6 +491,7 @@ async fn test_pack_invalid_ref_format() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_pack_valid_ref_formats() {
    let pool = create_test_pool().await.unwrap();

--- a/crates/common/tests/permission_repository_tests.rs
+++ b/crates/common/tests/permission_repository_tests.rs
@@ -168,6 +168,7 @@ impl PermissionSetFixture {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_permission_set_minimal() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = PermissionSetFixture::new(pool.clone());
@@ -196,6 +197,7 @@ async fn test_create_permission_set_minimal() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_permission_set_with_pack() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = PermissionSetFixture::new(pool.clone());
@@ -226,6 +228,7 @@ async fn test_create_permission_set_with_pack() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_permission_set_with_complex_grants() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = PermissionSetFixture::new(pool.clone());
@@ -250,6 +253,7 @@ async fn test_create_permission_set_with_complex_grants() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_permission_set_ref_format_validation() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = PermissionSetFixture::new(pool.clone());
@@ -282,6 +286,7 @@ async fn test_permission_set_ref_format_validation() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_permission_set_ref_lowercase() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = PermissionSetFixture::new(pool.clone());
@@ -301,6 +306,7 @@ async fn test_permission_set_ref_lowercase() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_permission_set_duplicate_ref() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = PermissionSetFixture::new(pool.clone());
@@ -325,6 +331,7 @@ async fn test_permission_set_duplicate_ref() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_permission_set_by_id() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = PermissionSetFixture::new(pool.clone());
@@ -342,6 +349,7 @@ async fn test_find_permission_set_by_id() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_permission_set_by_id_not_found() {
    let pool = create_test_pool().await.expect("Failed to create pool");

@@ -353,6 +361,7 @@ async fn test_find_permission_set_by_id_not_found() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_list_permission_sets() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = PermissionSetFixture::new(pool.clone());
@@ -372,6 +381,7 @@ async fn test_list_permission_sets() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_permission_set_label() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = PermissionSetFixture::new(pool.clone());
@@ -393,6 +403,7 @@ async fn test_update_permission_set_label() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_permission_set_grants() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = PermissionSetFixture::new(pool.clone());
@@ -418,6 +429,7 @@ async fn test_update_permission_set_grants() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_permission_set_all_fields() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = PermissionSetFixture::new(pool.clone());
@@ -441,6 +453,7 @@ async fn test_update_permission_set_all_fields() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_permission_set_no_changes() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = PermissionSetFixture::new(pool.clone());
@@ -462,6 +475,7 @@ async fn test_update_permission_set_no_changes() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_permission_set_timestamps() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = PermissionSetFixture::new(pool.clone());
@@ -487,6 +501,7 @@ async fn test_update_permission_set_timestamps() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_delete_permission_set() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = PermissionSetFixture::new(pool.clone());
@@ -507,6 +522,7 @@ async fn test_delete_permission_set() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_delete_permission_set_not_found() {
    let pool = create_test_pool().await.expect("Failed to create pool");

@@ -518,6 +534,7 @@ async fn test_delete_permission_set_not_found() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_permission_set_cascade_from_pack() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = PermissionSetFixture::new(pool.clone());
@@ -538,6 +555,7 @@ async fn test_permission_set_cascade_from_pack() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_permission_set_timestamps_auto_set() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = PermissionSetFixture::new(pool.clone());
@@ -557,6 +575,7 @@ async fn test_permission_set_timestamps_auto_set() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_permission_assignment() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = PermissionSetFixture::new(pool.clone());
@@ -572,6 +591,7 @@ async fn test_create_permission_assignment() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_permission_assignment_duplicate() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = PermissionSetFixture::new(pool.clone());
@@ -593,6 +613,7 @@ async fn test_create_permission_assignment_duplicate() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_permission_assignment_invalid_identity() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = PermissionSetFixture::new(pool.clone());
@@ -609,6 +630,7 @@ async fn test_create_permission_assignment_invalid_identity() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_permission_assignment_invalid_permset() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = PermissionSetFixture::new(pool.clone());
@@ -625,6 +647,7 @@ async fn test_create_permission_assignment_invalid_permset() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_permission_assignment_by_id() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = PermissionSetFixture::new(pool.clone());
@@ -644,6 +667,7 @@ async fn test_find_permission_assignment_by_id() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_permission_assignment_by_id_not_found() {
    let pool = create_test_pool().await.expect("Failed to create pool");

@@ -655,6 +679,7 @@ async fn test_find_permission_assignment_by_id_not_found() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_list_permission_assignments() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = PermissionSetFixture::new(pool.clone());
@@ -676,6 +701,7 @@ async fn test_list_permission_assignments() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_assignments_by_identity() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = PermissionSetFixture::new(pool.clone());
@@ -700,6 +726,7 @@ async fn test_find_assignments_by_identity() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_assignments_by_identity_empty() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = PermissionSetFixture::new(pool.clone());
@@ -714,6 +741,7 @@ async fn test_find_assignments_by_identity_empty() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_delete_permission_assignment() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = PermissionSetFixture::new(pool.clone());
@@ -736,6 +764,7 @@ async fn test_delete_permission_assignment() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_delete_permission_assignment_not_found() {
    let pool = create_test_pool().await.expect("Failed to create pool");

@@ -747,6 +776,7 @@ async fn test_delete_permission_assignment_not_found() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_permission_assignment_cascade_from_identity() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = PermissionSetFixture::new(pool.clone());
@@ -769,6 +799,7 @@ async fn test_permission_assignment_cascade_from_identity() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_permission_assignment_cascade_from_permset() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = PermissionSetFixture::new(pool.clone());
@@ -791,6 +822,7 @@ async fn test_permission_assignment_cascade_from_permset() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_permission_assignment_timestamp_auto_set() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = PermissionSetFixture::new(pool.clone());
@@ -807,6 +839,7 @@ async fn test_permission_assignment_timestamp_auto_set() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_multiple_identities_same_permset() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = PermissionSetFixture::new(pool.clone());
@@ -832,6 +865,7 @@ async fn test_multiple_identities_same_permset() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_one_identity_multiple_permsets() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = PermissionSetFixture::new(pool.clone());
@@ -864,6 +898,7 @@ async fn test_one_identity_multiple_permsets() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_permission_set_ordering() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = PermissionSetFixture::new(pool.clone());
@@ -904,6 +939,7 @@ async fn test_permission_set_ordering() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_permission_assignment_ordering() {
    let pool = create_test_pool().await.expect("Failed to create pool");
    let fixture = PermissionSetFixture::new(pool.clone());
--- a/crates/common/tests/queue_stats_repository_tests.rs
+++ b/crates/common/tests/queue_stats_repository_tests.rs
@@ -9,6 +9,7 @@ mod helpers;
 use helpers::{ActionFixture, PackFixture};

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_upsert_queue_stats() {
    let pool = helpers::create_test_pool().await.unwrap();

@@ -66,6 +67,7 @@ async fn test_upsert_queue_stats() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_queue_stats_by_action() {
    let pool = helpers::create_test_pool().await.unwrap();

@@ -107,6 +109,7 @@ async fn test_find_queue_stats_by_action() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_list_active_queue_stats() {
    let pool = helpers::create_test_pool().await.unwrap();

@@ -171,6 +174,7 @@ async fn test_list_active_queue_stats() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_delete_queue_stats() {
    let pool = helpers::create_test_pool().await.unwrap();

@@ -220,6 +224,7 @@ async fn test_delete_queue_stats() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_batch_upsert_queue_stats() {
    let pool = helpers::create_test_pool().await.unwrap();

@@ -262,6 +267,7 @@ async fn test_batch_upsert_queue_stats() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_clear_stale_queue_stats() {
    let pool = helpers::create_test_pool().await.unwrap();

@@ -301,6 +307,7 @@ async fn test_clear_stale_queue_stats() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_queue_stats_cascade_delete() {
    let pool = helpers::create_test_pool().await.unwrap();

--- a/crates/common/tests/repository_artifact_tests.rs
+++ b/crates/common/tests/repository_artifact_tests.rs
@@ -90,6 +90,7 @@ async fn setup_db() -> PgPool {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_artifact() {
    let pool = setup_db().await;
    let fixture = ArtifactFixture::new("create_artifact");
@@ -109,6 +110,7 @@ async fn test_create_artifact() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_by_id_exists() {
    let pool = setup_db().await;
    let fixture = ArtifactFixture::new("find_by_id_exists");
@@ -130,6 +132,7 @@ async fn test_find_by_id_exists() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_by_id_not_exists() {
    let pool = setup_db().await;
    let non_existent_id = 999_999_999_999i64;
@@ -142,6 +145,7 @@ async fn test_find_by_id_not_exists() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_get_by_id_not_found_error() {
    let pool = setup_db().await;
    let non_existent_id = 999_999_999_998i64;
@@ -158,6 +162,7 @@ async fn test_get_by_id_not_found_error() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_by_ref_exists() {
    let pool = setup_db().await;
    let fixture = ArtifactFixture::new("find_by_ref_exists");
@@ -177,6 +182,7 @@ async fn test_find_by_ref_exists() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_by_ref_not_exists() {
    let pool = setup_db().await;
    let fixture = ArtifactFixture::new("find_by_ref_not_exists");
@@ -189,6 +195,7 @@ async fn test_find_by_ref_not_exists() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_list_artifacts() {
    let pool = setup_db().await;
    let fixture = ArtifactFixture::new("list");
@@ -215,6 +222,7 @@ async fn test_list_artifacts() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_artifact_ref() {
    let pool = setup_db().await;
    let fixture = ArtifactFixture::new("update_ref");
@@ -241,6 +249,7 @@ async fn test_update_artifact_ref() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_artifact_all_fields() {
    let pool = setup_db().await;
    let fixture = ArtifactFixture::new("update_all");
@@ -285,6 +294,7 @@ async fn test_update_artifact_all_fields() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_artifact_no_changes() {
    let pool = setup_db().await;
    let fixture = ArtifactFixture::new("update_no_changes");
@@ -306,6 +316,7 @@ async fn test_update_artifact_no_changes() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_delete_artifact() {
    let pool = setup_db().await;
    let fixture = ArtifactFixture::new("delete");
@@ -329,6 +340,7 @@ async fn test_delete_artifact() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_delete_artifact_not_exists() {
    let pool = setup_db().await;
    let non_existent_id = 999_999_999_997i64;
@@ -345,6 +357,7 @@ async fn test_delete_artifact_not_exists() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_artifact_all_types() {
    let pool = setup_db().await;
    let fixture = ArtifactFixture::new("all_types");
@@ -372,6 +385,7 @@ async fn test_artifact_all_types() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_artifact_all_scopes() {
    let pool = setup_db().await;
    let fixture = ArtifactFixture::new("all_scopes");
@@ -397,6 +411,7 @@ async fn test_artifact_all_scopes() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_artifact_all_retention_policies() {
    let pool = setup_db().await;
    let fixture = ArtifactFixture::new("all_retention");
@@ -425,6 +440,7 @@ async fn test_artifact_all_retention_policies() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_by_scope() {
    let pool = setup_db().await;
    let fixture = ArtifactFixture::new("find_by_scope");
@@ -456,6 +472,7 @@ async fn test_find_by_scope() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_by_owner() {
    let pool = setup_db().await;
    let fixture = ArtifactFixture::new("find_by_owner");
@@ -486,6 +503,7 @@ async fn test_find_by_owner() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_by_type() {
    let pool = setup_db().await;
    let fixture = ArtifactFixture::new("find_by_type");
@@ -515,6 +533,7 @@ async fn test_find_by_type() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_by_scope_and_owner() {
    let pool = setup_db().await;
    let fixture = ArtifactFixture::new("find_by_scope_and_owner");
@@ -550,6 +569,7 @@ async fn test_find_by_scope_and_owner() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_by_retention_policy() {
    let pool = setup_db().await;
    let fixture = ArtifactFixture::new("find_by_retention");
@@ -584,6 +604,7 @@ async fn test_find_by_retention_policy() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_timestamps_auto_set_on_create() {
    let pool = setup_db().await;
    let fixture = ArtifactFixture::new("timestamps_create");
@@ -599,6 +620,7 @@ async fn test_timestamps_auto_set_on_create() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_updated_timestamp_changes_on_update() {
    let pool = setup_db().await;
    let fixture = ArtifactFixture::new("timestamps_update");
@@ -629,6 +651,7 @@ async fn test_updated_timestamp_changes_on_update() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_artifact_with_empty_owner() {
    let pool = setup_db().await;
    let fixture = ArtifactFixture::new("empty_owner");
@@ -643,6 +666,7 @@ async fn test_artifact_with_empty_owner() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_artifact_with_special_characters_in_ref() {
    let pool = setup_db().await;
    let fixture = ArtifactFixture::new("special_chars");
@@ -660,6 +684,7 @@ async fn test_artifact_with_special_characters_in_ref() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_artifact_with_zero_retention_limit() {
    let pool = setup_db().await;
    let fixture = ArtifactFixture::new("zero_retention");
@@ -674,6 +699,7 @@ async fn test_artifact_with_zero_retention_limit() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_artifact_with_negative_retention_limit() {
    let pool = setup_db().await;
    let fixture = ArtifactFixture::new("negative_retention");
@@ -688,6 +714,7 @@ async fn test_artifact_with_negative_retention_limit() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_artifact_with_large_retention_limit() {
    let pool = setup_db().await;
    let fixture = ArtifactFixture::new("large_retention");
@@ -702,6 +729,7 @@ async fn test_artifact_with_large_retention_limit() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_artifact_with_long_ref() {
    let pool = setup_db().await;
    let fixture = ArtifactFixture::new("long_ref");
@@ -716,6 +744,7 @@ async fn test_artifact_with_long_ref() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_multiple_artifacts_same_ref_allowed() {
    let pool = setup_db().await;
    let fixture = ArtifactFixture::new("duplicate_ref");
@@ -744,6 +773,7 @@ async fn test_multiple_artifacts_same_ref_allowed() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_by_scope_ordered_by_created() {
    let pool = setup_db().await;
    let fixture = ArtifactFixture::new("scope_ordering");
--- a/crates/common/tests/repository_runtime_tests.rs
+++ b/crates/common/tests/repository_runtime_tests.rs
@@ -117,6 +117,7 @@ async fn setup_db() -> PgPool {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_runtime() {
    let pool = setup_db().await;
    let fixture = RuntimeFixture::new("create_runtime");
@@ -139,6 +140,7 @@ async fn test_create_runtime() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_runtime_minimal() {
    let pool = setup_db().await;
    let fixture = RuntimeFixture::new("create_runtime_minimal");
@@ -157,6 +159,7 @@ async fn test_create_runtime_minimal() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_runtime_by_id() {
    let pool = setup_db().await;
    let fixture = RuntimeFixture::new("find_by_id");
@@ -176,6 +179,7 @@ async fn test_find_runtime_by_id() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_runtime_by_id_not_found() {
    let pool = setup_db().await;

@@ -187,6 +191,7 @@ async fn test_find_runtime_by_id_not_found() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_runtime_by_ref() {
    let pool = setup_db().await;
    let fixture = RuntimeFixture::new("find_by_ref");
@@ -206,6 +211,7 @@ async fn test_find_runtime_by_ref() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_runtime_by_ref_not_found() {
    let pool = setup_db().await;

@@ -217,6 +223,7 @@ async fn test_find_runtime_by_ref_not_found() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_list_runtimes() {
    let pool = setup_db().await;
    let fixture = RuntimeFixture::new("list_runtimes");
@@ -241,6 +248,7 @@ async fn test_list_runtimes() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_runtime() {
    let pool = setup_db().await;
    let fixture = RuntimeFixture::new("update_runtime");
@@ -275,6 +283,7 @@ async fn test_update_runtime() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_runtime_partial() {
    let pool = setup_db().await;
    let fixture = RuntimeFixture::new("update_partial");
@@ -303,6 +312,7 @@ async fn test_update_runtime_partial() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_runtime_empty() {
    let pool = setup_db().await;
    let fixture = RuntimeFixture::new("update_empty");
@@ -325,6 +335,7 @@ async fn test_update_runtime_empty() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_delete_runtime() {
    let pool = setup_db().await;
    let fixture = RuntimeFixture::new("delete_runtime");
@@ -348,6 +359,7 @@ async fn test_delete_runtime() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_delete_runtime_not_found() {
    let pool = setup_db().await;

@@ -373,6 +385,7 @@ async fn test_delete_runtime_not_found() {
 // }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_by_pack() {
    let pool = setup_db().await;
    let fixture = RuntimeFixture::new("find_by_pack");
@@ -434,6 +447,7 @@ async fn test_find_by_pack() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_by_pack_empty() {
    let pool = setup_db().await;

@@ -445,6 +459,7 @@ async fn test_find_by_pack_empty() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_runtime_created_successfully() {
    let pool = setup_db().await;
    let fixture = RuntimeFixture::new("created_test");
@@ -467,6 +482,7 @@ async fn test_runtime_created_successfully() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_duplicate_ref_fails() {
    let pool = setup_db().await;
    let fixture = RuntimeFixture::new("duplicate_ref");
@@ -482,6 +498,7 @@ async fn test_duplicate_ref_fails() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_json_fields() {
    let pool = setup_db().await;
    let fixture = RuntimeFixture::new("json_fields");
@@ -500,6 +517,7 @@ async fn test_json_fields() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_empty_json_distributions() {
    let pool = setup_db().await;
    let fixture = RuntimeFixture::new("empty_json");
@@ -516,6 +534,7 @@ async fn test_empty_json_distributions() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_list_ordering() {
    let pool = setup_db().await;
    let fixture = RuntimeFixture::new("list_ordering");
@@ -558,6 +577,7 @@ async fn test_list_ordering() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_timestamps() {
    let pool = setup_db().await;
    let fixture = RuntimeFixture::new("timestamps");
@@ -577,6 +597,7 @@ async fn test_timestamps() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_changes_timestamp() {
    let pool = setup_db().await;
    let fixture = RuntimeFixture::new("timestamp_update");
@@ -602,6 +623,7 @@ async fn test_update_changes_timestamp() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_pack_ref_without_pack_id() {
    let pool = setup_db().await;
    let fixture = RuntimeFixture::new("pack_ref_only");
--- a/crates/common/tests/repository_worker_tests.rs
+++ b/crates/common/tests/repository_worker_tests.rs
@@ -101,6 +101,7 @@ async fn setup_db() -> PgPool {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_worker() {
    let pool = setup_db().await;
    let fixture = WorkerFixture::new("create_worker");
@@ -125,6 +126,7 @@ async fn test_create_worker() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_worker_minimal() {
    let pool = setup_db().await;
    let fixture = WorkerFixture::new("create_worker_minimal");
@@ -145,6 +147,7 @@ async fn test_create_worker_minimal() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_worker_by_id() {
    let pool = setup_db().await;
    let fixture = WorkerFixture::new("find_by_id");
@@ -165,6 +168,7 @@ async fn test_find_worker_by_id() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_worker_by_id_not_found() {
    let pool = setup_db().await;

@@ -176,6 +180,7 @@ async fn test_find_worker_by_id_not_found() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_worker_by_name() {
    let pool = setup_db().await;
    let fixture = WorkerFixture::new("find_by_name");
@@ -195,6 +200,7 @@ async fn test_find_worker_by_name() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_worker_by_name_not_found() {
    let pool = setup_db().await;

@@ -206,6 +212,7 @@ async fn test_find_worker_by_name_not_found() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_list_workers() {
    let pool = setup_db().await;
    let fixture = WorkerFixture::new("list_workers");
@@ -230,6 +237,7 @@ async fn test_list_workers() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_worker() {
    let pool = setup_db().await;
    let fixture = WorkerFixture::new("update_worker");
@@ -267,6 +275,7 @@ async fn test_update_worker() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_worker_partial() {
    let pool = setup_db().await;
    let fixture = WorkerFixture::new("update_partial");
@@ -298,6 +307,7 @@ async fn test_update_worker_partial() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_worker_empty() {
    let pool = setup_db().await;
    let fixture = WorkerFixture::new("update_empty");
@@ -320,6 +330,7 @@ async fn test_update_worker_empty() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_delete_worker() {
    let pool = setup_db().await;
    let fixture = WorkerFixture::new("delete_worker");
@@ -343,6 +354,7 @@ async fn test_delete_worker() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_delete_worker_not_found() {
    let pool = setup_db().await;

@@ -358,6 +370,7 @@ async fn test_delete_worker_not_found() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_by_status_active() {
    let pool = setup_db().await;
    let fixture = WorkerFixture::new("find_by_status_active");
@@ -393,6 +406,7 @@ async fn test_find_by_status_active() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_by_status_all_statuses() {
    let pool = setup_db().await;
    let fixture = WorkerFixture::new("find_by_status_all");
@@ -421,6 +435,7 @@ async fn test_find_by_status_all_statuses() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_by_type_local() {
    let pool = setup_db().await;
    let fixture = WorkerFixture::new("find_by_type_local");
@@ -451,6 +466,7 @@ async fn test_find_by_type_local() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_by_type_all_types() {
    let pool = setup_db().await;
    let fixture = WorkerFixture::new("find_by_type_all");
@@ -474,6 +490,7 @@ async fn test_find_by_type_all_types() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_heartbeat() {
    let pool = setup_db().await;
    let fixture = WorkerFixture::new("update_heartbeat");
@@ -503,6 +520,7 @@ async fn test_update_heartbeat() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_heartbeat_multiple_times() {
    let pool = setup_db().await;
    let fixture = WorkerFixture::new("heartbeat_multiple");
@@ -544,6 +562,7 @@ async fn test_update_heartbeat_multiple_times() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_worker_with_runtime() {
    let pool = setup_db().await;
    let fixture = WorkerFixture::new("with_runtime");
@@ -593,6 +612,7 @@ async fn test_worker_with_runtime() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_worker_type_local() {
    let pool = setup_db().await;
    let fixture = WorkerFixture::new("type_local");
@@ -606,6 +626,7 @@ async fn test_worker_type_local() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_worker_type_remote() {
    let pool = setup_db().await;
    let fixture = WorkerFixture::new("type_remote");
@@ -619,6 +640,7 @@ async fn test_worker_type_remote() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_worker_type_container() {
    let pool = setup_db().await;
    let fixture = WorkerFixture::new("type_container");
@@ -632,6 +654,7 @@ async fn test_worker_type_container() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_worker_status_active() {
    let pool = setup_db().await;
    let fixture = WorkerFixture::new("status_active");
@@ -646,6 +669,7 @@ async fn test_worker_status_active() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_worker_status_inactive() {
    let pool = setup_db().await;
    let fixture = WorkerFixture::new("status_inactive");
@@ -660,6 +684,7 @@ async fn test_worker_status_inactive() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_worker_status_busy() {
    let pool = setup_db().await;
    let fixture = WorkerFixture::new("status_busy");
@@ -674,6 +699,7 @@ async fn test_worker_status_busy() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_worker_status_error() {
    let pool = setup_db().await;
    let fixture = WorkerFixture::new("status_error");
@@ -692,6 +718,7 @@ async fn test_worker_status_error() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_duplicate_name_allowed() {
    let pool = setup_db().await;
    let fixture = WorkerFixture::new("duplicate_name");
@@ -718,6 +745,7 @@ async fn test_duplicate_name_allowed() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_json_fields() {
    let pool = setup_db().await;
    let fixture = WorkerFixture::new("json_fields");
@@ -737,6 +765,7 @@ async fn test_json_fields() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_null_json_fields() {
    let pool = setup_db().await;
    let fixture = WorkerFixture::new("null_json");
@@ -751,6 +780,7 @@ async fn test_null_json_fields() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_null_status() {
    let pool = setup_db().await;
    let fixture = WorkerFixture::new("null_status");
@@ -765,6 +795,7 @@ async fn test_null_status() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_list_ordering() {
    let pool = setup_db().await;
    let fixture = WorkerFixture::new("list_ordering");
@@ -807,6 +838,7 @@ async fn test_list_ordering() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_timestamps() {
    let pool = setup_db().await;
    let fixture = WorkerFixture::new("timestamps");
@@ -826,6 +858,7 @@ async fn test_timestamps() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_changes_timestamp() {
    let pool = setup_db().await;
    let fixture = WorkerFixture::new("timestamp_update");
@@ -851,6 +884,7 @@ async fn test_update_changes_timestamp() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_heartbeat_updates_timestamp() {
    let pool = setup_db().await;
    let fixture = WorkerFixture::new("heartbeat_updates");
@@ -879,6 +913,7 @@ async fn test_heartbeat_updates_timestamp() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_port_range() {
    let pool = setup_db().await;
    let fixture = WorkerFixture::new("port_range");
@@ -899,6 +934,7 @@ async fn test_port_range() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_status_lifecycle() {
    let pool = setup_db().await;
    let fixture = WorkerFixture::new("status_lifecycle");
--- a/crates/common/tests/rule_repository_tests.rs
+++ b/crates/common/tests/rule_repository_tests.rs
@@ -20,6 +20,7 @@ use serde_json::json;
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_rule() {
    let pool = create_test_pool().await.unwrap();

@@ -80,6 +81,7 @@ async fn test_create_rule() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_rule_disabled() {
    let pool = create_test_pool().await.unwrap();

@@ -121,6 +123,7 @@ async fn test_create_rule_disabled() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_rule_with_complex_conditions() {
    let pool = create_test_pool().await.unwrap();

@@ -170,6 +173,7 @@ async fn test_create_rule_with_complex_conditions() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_rule_duplicate_ref() {
    let pool = create_test_pool().await.unwrap();

@@ -246,6 +250,7 @@ async fn test_create_rule_duplicate_ref() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_rule_invalid_ref_format_uppercase() {
    let pool = create_test_pool().await.unwrap();

@@ -287,6 +292,7 @@ async fn test_create_rule_invalid_ref_format_uppercase() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_rule_invalid_ref_format_no_dot() {
    let pool = create_test_pool().await.unwrap();

@@ -332,6 +338,7 @@ async fn test_create_rule_invalid_ref_format_no_dot() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_rule_by_id() {
    let pool = create_test_pool().await.unwrap();

@@ -380,6 +387,7 @@ async fn test_find_rule_by_id() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_rule_by_id_not_found() {
    let pool = create_test_pool().await.unwrap();

@@ -389,6 +397,7 @@ async fn test_find_rule_by_id_not_found() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_rule_by_ref() {
    let pool = create_test_pool().await.unwrap();

@@ -437,6 +446,7 @@ async fn test_find_rule_by_ref() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_rule_by_ref_not_found() {
    let pool = create_test_pool().await.unwrap();

@@ -448,6 +458,7 @@ async fn test_find_rule_by_ref_not_found() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_list_rules() {
    let pool = create_test_pool().await.unwrap();

@@ -500,6 +511,7 @@ async fn test_list_rules() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_list_rules_ordered_by_ref() {
    let pool = create_test_pool().await.unwrap();

@@ -558,6 +570,7 @@ async fn test_list_rules_ordered_by_ref() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_rule_label() {
    let pool = create_test_pool().await.unwrap();

@@ -610,6 +623,7 @@ async fn test_update_rule_label() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_rule_description() {
    let pool = create_test_pool().await.unwrap();

@@ -660,6 +674,7 @@ async fn test_update_rule_description() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_rule_conditions() {
    let pool = create_test_pool().await.unwrap();

@@ -711,6 +726,7 @@ async fn test_update_rule_conditions() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_rule_enabled() {
    let pool = create_test_pool().await.unwrap();

@@ -763,6 +779,7 @@ async fn test_update_rule_enabled() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_rule_multiple_fields() {
    let pool = create_test_pool().await.unwrap();

@@ -820,6 +837,7 @@ async fn test_update_rule_multiple_fields() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_rule_no_changes() {
    let pool = create_test_pool().await.unwrap();

@@ -872,6 +890,7 @@ async fn test_update_rule_no_changes() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_delete_rule() {
    let pool = create_test_pool().await.unwrap();

@@ -919,6 +938,7 @@ async fn test_delete_rule() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_delete_rule_not_found() {
    let pool = create_test_pool().await.unwrap();

@@ -932,6 +952,7 @@ async fn test_delete_rule_not_found() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_rules_by_pack() {
    let pool = create_test_pool().await.unwrap();

@@ -1021,6 +1042,7 @@ async fn test_find_rules_by_pack() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_rules_by_action() {
    let pool = create_test_pool().await.unwrap();

@@ -1102,6 +1124,7 @@ async fn test_find_rules_by_action() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_rules_by_trigger() {
    let pool = create_test_pool().await.unwrap();

@@ -1185,6 +1208,7 @@ async fn test_find_rules_by_trigger() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_enabled_rules() {
    let pool = create_test_pool().await.unwrap();

@@ -1264,6 +1288,7 @@ async fn test_find_enabled_rules() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_cascade_delete_pack_deletes_rules() {
    let pool = create_test_pool().await.unwrap();

@@ -1319,6 +1344,7 @@ async fn test_cascade_delete_pack_deletes_rules() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_rule_timestamps() {
    let pool = create_test_pool().await.unwrap();

--- a/crates/common/tests/sensor_repository_tests.rs
+++ b/crates/common/tests/sensor_repository_tests.rs
@@ -20,6 +20,7 @@ use serde_json::json;
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_sensor_minimal() {
    let pool = create_test_pool().await.unwrap();

@@ -68,6 +69,7 @@ async fn test_create_sensor_minimal() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_sensor_with_param_schema() {
    let pool = create_test_pool().await.unwrap();

@@ -119,6 +121,7 @@ async fn test_create_sensor_with_param_schema() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_sensor_without_pack() {
    let pool = create_test_pool().await.unwrap();

@@ -150,6 +153,7 @@ async fn test_create_sensor_without_pack() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_sensor_duplicate_ref_fails() {
    let pool = create_test_pool().await.unwrap();

@@ -199,6 +203,7 @@ async fn test_create_sensor_duplicate_ref_fails() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_sensor_invalid_ref_format_fails() {
    let pool = create_test_pool().await.unwrap();

@@ -252,6 +257,7 @@ async fn test_create_sensor_invalid_ref_format_fails() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_sensor_invalid_pack_fails() {
    let pool = create_test_pool().await.unwrap();

@@ -288,6 +294,7 @@ async fn test_create_sensor_invalid_pack_fails() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_sensor_invalid_trigger_fails() {
    let pool = create_test_pool().await.unwrap();

@@ -319,6 +326,7 @@ async fn test_create_sensor_invalid_trigger_fails() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_sensor_invalid_runtime_fails() {
    let pool = create_test_pool().await.unwrap();

@@ -354,6 +362,7 @@ async fn test_create_sensor_invalid_runtime_fails() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_by_id_exists() {
    let pool = create_test_pool().await.unwrap();

@@ -397,6 +406,7 @@ async fn test_find_by_id_exists() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_by_id_not_exists() {
    let pool = create_test_pool().await.unwrap();

@@ -405,6 +415,7 @@ async fn test_find_by_id_not_exists() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_get_by_id_exists() {
    let pool = create_test_pool().await.unwrap();

@@ -443,6 +454,7 @@ async fn test_get_by_id_exists() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_get_by_id_not_exists_fails() {
    let pool = create_test_pool().await.unwrap();

@@ -452,6 +464,7 @@ async fn test_get_by_id_not_exists_fails() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_by_ref_exists() {
    let pool = create_test_pool().await.unwrap();

@@ -494,6 +507,7 @@ async fn test_find_by_ref_exists() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_by_ref_not_exists() {
    let pool = create_test_pool().await.unwrap();

@@ -504,6 +518,7 @@ async fn test_find_by_ref_not_exists() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_get_by_ref_exists() {
    let pool = create_test_pool().await.unwrap();

@@ -544,6 +559,7 @@ async fn test_get_by_ref_exists() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_get_by_ref_not_exists_fails() {
    let pool = create_test_pool().await.unwrap();

@@ -553,6 +569,7 @@ async fn test_get_by_ref_not_exists_fails() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_list_all_sensors() {
    let pool = create_test_pool().await.unwrap();

@@ -610,6 +627,7 @@ async fn test_list_all_sensors() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_list_empty() {
    let pool = create_test_pool().await.unwrap();

@@ -624,6 +642,7 @@ async fn test_list_empty() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_label() {
    let pool = create_test_pool().await.unwrap();

@@ -676,6 +695,7 @@ async fn test_update_label() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_description() {
    let pool = create_test_pool().await.unwrap();

@@ -720,6 +740,7 @@ async fn test_update_description() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_entrypoint() {
    let pool = create_test_pool().await.unwrap();

@@ -764,6 +785,7 @@ async fn test_update_entrypoint() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_enabled_status() {
    let pool = create_test_pool().await.unwrap();

@@ -823,6 +845,7 @@ async fn test_update_enabled_status() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_param_schema() {
    let pool = create_test_pool().await.unwrap();

@@ -877,6 +900,7 @@ async fn test_update_param_schema() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_multiple_fields() {
    let pool = create_test_pool().await.unwrap();

@@ -929,6 +953,7 @@ async fn test_update_multiple_fields() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_no_changes() {
    let pool = create_test_pool().await.unwrap();

@@ -978,6 +1003,7 @@ async fn test_update_no_changes() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_nonexistent_sensor_fails() {
    let pool = create_test_pool().await.unwrap();

@@ -995,6 +1021,7 @@ async fn test_update_nonexistent_sensor_fails() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_delete_existing_sensor() {
    let pool = create_test_pool().await.unwrap();

@@ -1037,6 +1064,7 @@ async fn test_delete_existing_sensor() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_delete_nonexistent_sensor() {
    let pool = create_test_pool().await.unwrap();

@@ -1045,6 +1073,7 @@ async fn test_delete_nonexistent_sensor() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_delete_sensor_when_pack_deleted() {
    let pool = create_test_pool().await.unwrap();

@@ -1088,6 +1117,7 @@ async fn test_delete_sensor_when_pack_deleted() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_delete_sensor_when_trigger_deleted() {
    let pool = create_test_pool().await.unwrap();

@@ -1131,6 +1161,7 @@ async fn test_delete_sensor_when_trigger_deleted() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_delete_sensor_when_runtime_deleted() {
    let pool = create_test_pool().await.unwrap();

@@ -1178,6 +1209,7 @@ async fn test_delete_sensor_when_runtime_deleted() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_by_trigger() {
    let pool = create_test_pool().await.unwrap();

@@ -1252,6 +1284,7 @@ async fn test_find_by_trigger() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_by_trigger_no_sensors() {
    let pool = create_test_pool().await.unwrap();

@@ -1273,6 +1306,7 @@ async fn test_find_by_trigger_no_sensors() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_enabled() {
    let pool = create_test_pool().await.unwrap();

@@ -1329,6 +1363,7 @@ async fn test_find_enabled() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_enabled_empty() {
    let pool = create_test_pool().await.unwrap();

@@ -1368,6 +1403,7 @@ async fn test_find_enabled_empty() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_by_pack() {
    let pool = create_test_pool().await.unwrap();

@@ -1453,6 +1489,7 @@ async fn test_find_by_pack() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_by_pack_no_sensors() {
    let pool = create_test_pool().await.unwrap();

@@ -1473,6 +1510,7 @@ async fn test_find_by_pack_no_sensors() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_created_timestamp_set_automatically() {
    let pool = create_test_pool().await.unwrap();

@@ -1514,6 +1552,7 @@ async fn test_created_timestamp_set_automatically() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_updated_timestamp_changes_on_update() {
    let pool = create_test_pool().await.unwrap();

@@ -1564,6 +1603,7 @@ async fn test_updated_timestamp_changes_on_update() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_updated_timestamp_unchanged_on_read() {
    let pool = create_test_pool().await.unwrap();

@@ -1614,6 +1654,7 @@ async fn test_updated_timestamp_unchanged_on_read() {
 // ============================================================================

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_param_schema_complex_structure() {
    let pool = create_test_pool().await.unwrap();

@@ -1688,6 +1729,7 @@ async fn test_param_schema_complex_structure() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_param_schema_can_be_null() {
    let pool = create_test_pool().await.unwrap();

--- a/crates/common/tests/trigger_repository_tests.rs
+++ b/crates/common/tests/trigger_repository_tests.rs
@@ -16,6 +16,7 @@ use helpers::*;
 use serde_json::json;

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_trigger() {
    let pool = create_test_pool().await.unwrap();

@@ -48,6 +49,7 @@ async fn test_create_trigger() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_trigger_without_pack() {
    let pool = create_test_pool().await.unwrap();

@@ -72,6 +74,7 @@ async fn test_create_trigger_without_pack() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_trigger_with_schemas() {
    let pool = create_test_pool().await.unwrap();

@@ -116,6 +119,7 @@ async fn test_create_trigger_with_schemas() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_trigger_disabled() {
    let pool = create_test_pool().await.unwrap();

@@ -138,6 +142,7 @@ async fn test_create_trigger_disabled() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_create_trigger_duplicate_ref() {
    let pool = create_test_pool().await.unwrap();

@@ -182,6 +187,7 @@ async fn test_create_trigger_duplicate_ref() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_trigger_by_id() {
    let pool = create_test_pool().await.unwrap();

@@ -215,6 +221,7 @@ async fn test_find_trigger_by_id() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_trigger_by_id_not_found() {
    let pool = create_test_pool().await.unwrap();

@@ -224,6 +231,7 @@ async fn test_find_trigger_by_id_not_found() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_trigger_by_ref() {
    let pool = create_test_pool().await.unwrap();

@@ -257,6 +265,7 @@ async fn test_find_trigger_by_ref() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_trigger_by_ref_not_found() {
    let pool = create_test_pool().await.unwrap();

@@ -268,6 +277,7 @@ async fn test_find_trigger_by_ref_not_found() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_list_triggers() {
    let pool = create_test_pool().await.unwrap();

@@ -314,6 +324,7 @@ async fn test_list_triggers() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_triggers_by_pack() {
    let pool = create_test_pool().await.unwrap();

@@ -384,6 +395,7 @@ async fn test_find_triggers_by_pack() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_enabled_triggers() {
    let pool = create_test_pool().await.unwrap();

@@ -436,6 +448,7 @@ async fn test_find_enabled_triggers() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_trigger() {
    let pool = create_test_pool().await.unwrap();

@@ -483,6 +496,7 @@ async fn test_update_trigger() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_trigger_partial() {
    let pool = create_test_pool().await.unwrap();

@@ -520,6 +534,7 @@ async fn test_update_trigger_partial() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_trigger_schemas() {
    let pool = create_test_pool().await.unwrap();

@@ -569,6 +584,7 @@ async fn test_update_trigger_schemas() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_update_trigger_not_found() {
    let pool = create_test_pool().await.unwrap();

@@ -593,6 +609,7 @@ async fn test_update_trigger_not_found() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_delete_trigger() {
    let pool = create_test_pool().await.unwrap();

@@ -629,6 +646,7 @@ async fn test_delete_trigger() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_delete_trigger_not_found() {
    let pool = create_test_pool().await.unwrap();

@@ -638,6 +656,7 @@ async fn test_delete_trigger_not_found() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_trigger_timestamps_auto_populated() {
    let pool = create_test_pool().await.unwrap();

@@ -666,6 +685,7 @@ async fn test_trigger_timestamps_auto_populated() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_trigger_updated_changes_on_update() {
    let pool = create_test_pool().await.unwrap();

@@ -709,6 +729,7 @@ async fn test_trigger_updated_changes_on_update() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_multiple_triggers_same_pack() {
    let pool = create_test_pool().await.unwrap();

@@ -754,6 +775,7 @@ async fn test_multiple_triggers_same_pack() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_trigger_cascade_delete_with_pack() {
    let pool = create_test_pool().await.unwrap();

--- a/crates/common/tests/webhook_tests.rs
+++ b/crates/common/tests/webhook_tests.rs
@@ -36,6 +36,7 @@ async fn create_test_trigger(pool: &PgPool) -> Trigger {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_webhook_enable() {
    let pool = setup_test_db().await;
    let trigger = create_test_trigger(&pool).await;
@@ -76,6 +77,7 @@ async fn test_webhook_enable() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_webhook_disable() {
    let pool = setup_test_db().await;
    let trigger = create_test_trigger(&pool).await;
@@ -113,6 +115,7 @@ async fn test_webhook_disable() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_webhook_key_regeneration() {
    let pool = setup_test_db().await;
    let trigger = create_test_trigger(&pool).await;
@@ -153,6 +156,7 @@ async fn test_webhook_key_regeneration() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_find_by_webhook_key() {
    let pool = setup_test_db().await;
    let trigger = create_test_trigger(&pool).await;
@@ -189,6 +193,7 @@ async fn test_find_by_webhook_key() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_webhook_key_uniqueness() {
    let pool = setup_test_db().await;
    let trigger1 = create_test_trigger(&pool).await;
@@ -220,6 +225,7 @@ async fn test_webhook_key_uniqueness() {
 }

 #[tokio::test]
+#[ignore = "integration test — requires database"]
 async fn test_enable_webhook_idempotent() {
    let pool = setup_test_db().await;
    let trigger = create_test_trigger(&pool).await;