test(automation): isolate retained runtime fixtures

Author: ScriptedAlchemy

tests/automation_runner_test/combined_review.rs

@@ -46,6 +46,7 @@ fn combined_output_fixture() -> Value {
     })
 }
 
+#[cfg(feature = "test-transport")]
 #[tokio::test]
 async fn combined_review_runner_records_both_tasks_from_one_backend_call() {
     let _env_lock = ENV_LOCK.lock().await;
@@ -384,6 +385,7 @@ async fn combined_review_terminal_evidence_matrix_has_zero_effects() {
     assert!(!profile_root.exists());
 }
 
+#[cfg(feature = "test-transport")]
 #[tokio::test]
 async fn combined_review_records_failures_for_both_tasks_when_an_array_is_missing() {
     let _env_lock = ENV_LOCK.lock().await;
@@ -440,6 +442,7 @@ async fn combined_review_records_failures_for_both_tasks_when_an_array_is_missin
     );
 }
 
+#[cfg(feature = "test-transport")]
 #[tokio::test]
 async fn combined_review_records_noop_fallbacks_for_both_tasks_when_backend_fails() {
     let _env_lock = ENV_LOCK.lock().await;

tests/automation_runner_test/runner.rs

@@ -162,6 +162,7 @@ async fn scheduler_skill_writer_respects_interval_gate() {
     );
 }
 
+#[cfg(feature = "test-transport")]
 #[tokio::test]
 async fn scheduler_skill_writer_respects_idle_window_after_recent_session_activity() {
     let temp = tempdir().unwrap();
@@ -192,6 +193,7 @@ async fn scheduler_skill_writer_respects_idle_window_after_recent_session_activi
     );
 }
 
+#[cfg(feature = "test-transport")]
 #[tokio::test]
 async fn scheduler_skill_writer_skips_without_new_session_activity_since_last_success() {
     let temp = tempdir().unwrap();

tests/automation_runner_test/session_reflector.rs

@@ -1,4 +1,5 @@
 use crate::support::*;
+#[cfg(feature = "test-transport")]
 use tracedecay_agent_hosts::ports::session_evidence::{LcmGrepSort, LcmScope};
 
 #[test]
@@ -235,6 +236,7 @@ async fn project_reflector_and_skill_writer_terminal_evidence_matrix_has_zero_wr
     assert!(!profile_root.exists());
 }
 
+#[cfg(feature = "test-transport")]
 #[tokio::test]
 async fn session_reflector_runner_auto_applies_valid_fact_proposals_by_default() {
     let temp = tempdir().unwrap();
@@ -556,6 +558,7 @@ async fn session_reflector_runner_auto_applies_valid_fact_proposals_by_default()
     assert!(records[0].applied_ops.is_some());
 }
 
+#[cfg(feature = "test-transport")]
 #[tokio::test]
 async fn session_reflector_runner_auto_apply_ignores_dashboard_approval_gate() {
     const HIGH_ENTROPY_RUN_ID: &str =
@@ -722,6 +725,7 @@ async fn session_reflector_runner_auto_apply_ignores_dashboard_approval_gate() {
     );
 }
 
+#[cfg(feature = "test-transport")]
 #[tokio::test]
 async fn session_reflector_runner_self_manages_partial_noops_without_review_gate() {
     let temp = tempdir().unwrap();
@@ -884,6 +888,7 @@ async fn session_fact_proposals_replay_same_run_idempotently() {
     assert_eq!(proposals.proposals()[0].automation_run_id(), Some("run-a"));
 }
 
+#[cfg(feature = "test-transport")]
 #[tokio::test]
 async fn session_reflector_rejects_unsupported_source_role_and_time_filters_without_writes() {
     let _env_lock = ENV_LOCK.lock().await;
@@ -978,6 +983,7 @@ async fn session_reflector_rejects_unsupported_source_role_and_time_filters_with
     );
 }
 
+#[cfg(feature = "test-transport")]
 #[tokio::test]
 async fn session_reflector_replays_recent_sessions_without_keyword_matches() {
     let temp = tempdir().unwrap();
@@ -1058,6 +1064,7 @@ async fn session_reflector_replays_recent_sessions_without_keyword_matches() {
     assert_eq!(run.ledger_record.rejected_count, 0);
 }
 
+#[cfg(feature = "test-transport")]
 #[tokio::test]
 async fn session_reflector_suppresses_replay_for_filtered_runs() {
     let temp = tempdir().unwrap();
@@ -1155,8 +1162,10 @@ async fn session_reflector_skips_when_replay_disabled_and_no_grep_hits() {
     );
 }
 
+#[cfg(feature = "test-transport")]
 struct NoSummaryReplayBackend;
 
+#[cfg(feature = "test-transport")]
 impl AgentTaskBackend for NoSummaryReplayBackend {
     fn run_task(
         &self,
@@ -1189,6 +1198,7 @@ impl AgentTaskBackend for NoSummaryReplayBackend {
     }
 }
 
+#[cfg(feature = "test-transport")]
 #[tokio::test]
 async fn session_reflector_replay_respects_include_summaries_false() {
     let temp = tempdir().unwrap();
@@ -1263,6 +1273,7 @@ async fn session_reflector_replay_respects_include_summaries_false() {
     assert_eq!(run.ledger_record.status, AutomationRunStatus::Succeeded);
 }
 
+#[cfg(feature = "test-transport")]
 #[tokio::test]
 async fn session_reflector_runner_ledgers_malformed_backend_output() {
     let temp = tempdir().unwrap();
@@ -1326,6 +1337,7 @@ async fn session_reflector_runner_ledgers_malformed_backend_output() {
     assert_eq!(records[0].error_retryable, Some(false));
 }
 
+#[cfg(feature = "test-transport")]
 #[tokio::test]
 async fn session_reflector_runner_ledgers_missing_facts_array() {
     let temp = tempdir().unwrap();
@@ -1389,6 +1401,7 @@ async fn session_reflector_runner_ledgers_missing_facts_array() {
     assert_eq!(records[0].error_retryable, Some(false));
 }
 
+#[cfg(feature = "test-transport")]
 #[tokio::test]
 async fn session_reflector_runner_records_noop_fallback_when_backend_run_task_fails() {
     let temp = tempdir().unwrap();

tests/automation_runner_test/skill_writer.rs

@@ -95,6 +95,7 @@ async fn skill_writer_fails_closed_on_denied_temporal_evidence() {
 
 // Every test below that reaches evidence building holds `ENV_LOCK` and pins
 // its profile database override at the isolated session store.
+#[cfg(feature = "test-transport")]
 #[tokio::test]
 async fn skill_writer_default_provider_searches_all_providers() {
     let _env_lock = ENV_LOCK.lock().await;
@@ -136,6 +137,7 @@ async fn skill_writer_default_provider_searches_all_providers() {
     assert_eq!(run.ledger_record.status, AutomationRunStatus::Succeeded);
 }
 
+#[cfg(feature = "test-transport")]
 #[tokio::test]
 async fn skill_writer_replays_recent_sessions_without_keyword_matches() {
     let _env_lock = ENV_LOCK.lock().await;
@@ -217,6 +219,7 @@ async fn skill_writer_skips_when_replay_disabled_and_no_grep_hits() {
     );
 }
 
+#[cfg(feature = "test-transport")]
 #[tokio::test]
 async fn skill_writer_host_modes_do_not_select_alternate_lcm_storage() {
     let _env_lock = ENV_LOCK.lock().await;
@@ -280,6 +283,7 @@ async fn skill_writer_host_modes_do_not_select_alternate_lcm_storage() {
     assert_eq!(backend.calls(), 1);
 }
 
+#[cfg(feature = "test-transport")]
 #[tokio::test]
 async fn skill_writer_runner_creates_pending_skill_drafts_for_approval() {
     let _env_lock = ENV_LOCK.lock().await;
@@ -464,6 +468,7 @@ async fn skill_writer_runner_creates_pending_skill_drafts_for_approval() {
     );
 }
 
+#[cfg(feature = "test-transport")]
 #[tokio::test]
 async fn skill_writer_evidence_imports_project_skill_usage_analytics_before_summarizing() {
     let _env_lock = ENV_LOCK.lock().await;
@@ -548,6 +553,7 @@ async fn skill_writer_evidence_imports_project_skill_usage_analytics_before_summ
     );
 }
 
+#[cfg(feature = "test-transport")]
 #[tokio::test]
 async fn skill_writer_evidence_includes_underused_tool_family_summary() {
     let _env_lock = ENV_LOCK.lock().await;
@@ -579,6 +585,7 @@ async fn skill_writer_evidence_includes_underused_tool_family_summary() {
     assert_eq!(run.ledger_record.status, AutomationRunStatus::Succeeded);
 }
 
+#[cfg(feature = "test-transport")]
 #[tokio::test]
 async fn skill_writer_runner_auto_enables_when_config_explicitly_allows() {
     let _env_lock = ENV_LOCK.lock().await;
@@ -697,6 +704,7 @@ async fn skill_writer_runner_auto_enables_when_config_explicitly_allows() {
     assert!(updated.pending_update.is_none());
 }
 
+#[cfg(feature = "test-transport")]
 #[tokio::test]
 async fn skill_writer_runner_updates_existing_skills_with_checksum_precondition() {
     let _env_lock = ENV_LOCK.lock().await;
@@ -912,6 +920,7 @@ async fn skill_writer_runner_updates_existing_skills_with_checksum_precondition(
     );
 }
 
+#[cfg(feature = "test-transport")]
 #[tokio::test]
 async fn skill_writer_runner_ledgers_malformed_backend_output() {
     let _env_lock = ENV_LOCK.lock().await;
@@ -962,6 +971,7 @@ async fn skill_writer_runner_ledgers_malformed_backend_output() {
     assert_eq!(records[0].error_retryable, Some(false));
 }
 
+#[cfg(feature = "test-transport")]
 #[tokio::test]
 async fn skill_writer_runner_ledgers_missing_skills_array() {
     let _env_lock = ENV_LOCK.lock().await;
@@ -1013,6 +1023,7 @@ async fn skill_writer_runner_ledgers_missing_skills_array() {
     assert_eq!(records[0].error_retryable, Some(false));
 }
 
+#[cfg(feature = "test-transport")]
 #[tokio::test]
 async fn skill_writer_runner_records_noop_fallback_when_backend_run_task_fails() {
     let _env_lock = ENV_LOCK.lock().await;

tests/automation_runner_test/skill_writer_consolidation.rs

@@ -1,5 +1,7 @@
+#[cfg(feature = "test-transport")]
 use crate::support::*;
 
+#[cfg(feature = "test-transport")]
 #[tokio::test]
 async fn skill_writer_runner_auto_applies_safe_consolidations() {
     let _env_lock = ENV_LOCK.lock().await;

tests/automation_runner_test/support.rs

@@ -1034,13 +1034,15 @@ pub(crate) async fn init_project(project_root: &Path) -> TraceDecay {
     TraceDecay::init(project_root).await.unwrap()
 }
 
+#[cfg(feature = "test-transport")]
 pub(crate) async fn project_session_runtime(
     cg: &TraceDecay,
 ) -> std::sync::Arc<HostAdmissionTestRuntimeV1> {
     cg.test_runtime_for_test()
         .expect("project graph should retain its registered test runtime")
 }
 
+#[cfg(feature = "test-transport")]
 pub(crate) async fn seed_session_evidence(cg: &TraceDecay) {
     let db = project_session_runtime(cg).await;
     seed_session_message_in_db(
@@ -1059,6 +1061,7 @@ pub(crate) async fn seed_session_evidence(cg: &TraceDecay) {
     .await;
 }
 
+#[cfg(feature = "test-transport")]
 pub(crate) async fn seed_search_underuse_session_evidence(cg: &TraceDecay) {
     let db = project_session_runtime(cg).await;
     let session = SessionRecord {
@@ -1105,6 +1108,7 @@ pub(crate) async fn seed_search_underuse_session_evidence(cg: &TraceDecay) {
 
 /// Seeds one session message at `timestamp` so the scheduler observes LCM
 /// session activity at that instant.
+#[cfg(feature = "test-transport")]
 pub(crate) async fn seed_session_activity(cg: &TraceDecay, timestamp: i64) {
     let db = project_session_runtime(cg).await;
     seed_session_message_in_db(