diff --git a/.config/nextest.toml b/.config/nextest.toml
new file mode 100644
index 0000000..2a23fab
--- /dev/null
+++ b/.config/nextest.toml
@@ -0,0 +1,11 @@
+# .config/nextest.toml
+[profile.default]
+# Kill any test once it crosses 60s.
+slow-timeout = { period = "60s", terminate-after = 1, grace-period = "5s" }
+
+# Put a hard ceiling on the whole run.
+global-timeout = "10m"
+
+# Exclude cucumber BDD tests (they don't support nextest's --list command).
+# Run cucumber tests separately with `cargo test`.
+default-filter = "not binary(cucumber)"
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 63e2e06..d156353 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -17,6 +17,10 @@ jobs:
       - uses: actions/checkout@v5
       - name: Setup Rust
         uses: leynos/shared-actions/.github/actions/setup-rust@f9f1c863c8a5bef64aa6779caa746e1a4a6c1ad4
+      - name: Install nextest
+        uses: taiki-e/install-action@db22c42b5af88356329b9a8056bb2c2f026d5a10
+        with:
+          tool: nextest@0.9.114
       - name: Format
         run: make check-fmt
       - name: Lint
diff --git a/.markdownlint-cli2.jsonc b/.markdownlint-cli2.jsonc
index c9bb478..78fd680 100644
--- a/.markdownlint-cli2.jsonc
+++ b/.markdownlint-cli2.jsonc
@@ -1,11 +1,21 @@
 {
   "config": {
+    "MD004": { "style": "dash" },
+    "MD010": { "code_blocks": false },
     "MD013": {
       "line_length": 80,
       "code_block_line_length": 120,
-      "tables": false
+      "tables": false,
+      "headings": false
     },
-    "MD029": { "style": "ordered" },
-    "MD040": { "code_blocks": true }
-  }
+    "MD029": { "style": "ordered" }
+  },
+  "ignores": [
+    "**/.venv/**",
+    "**/node_modules/**",
+    "**/target/**",
+    "**/.terraform/**",
+    "**/.uv-cache/**",
+    "CRUSH.md"
+  ]
 }
diff --git a/Cargo.lock b/Cargo.lock
index 7b060d2..3109041 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2531,6 +2531,7 @@ dependencies = [
  "serial_test",
  "tempfile",
  "tokio",
+ "tracing-subscriber",
  "wiremock",
 ]
 
diff --git a/Makefile b/Makefile
index 4e9ff9f..a16030b 100644
--- a/Makefile
+++ b/Makefile
@@ -3,8 +3,8 @@
 APP ?= comenq
 CARGO ?= cargo
 BUILD_JOBS ?=
-CLIPPY_FLAGS ?= --all-targets --all-features -- -D warnings
-MDLINT ?= markdownlint
+CLIPPY_FLAGS ?= --workspace --all-targets --all-features -- -D warnings
+MDLINT ?= markdownlint-cli2
 NIXIE ?= nixie
 COV_MIN ?= 0 # Minimum line coverage percentage for coverage targets
 
@@ -34,16 +34,19 @@ clean: ## Remove build artefacts
 	rm -rf coverage
 
 test: ## Run tests with warnings treated as errors
-	RUSTFLAGS="-D warnings" $(CARGO) test --all-targets --all-features $(BUILD_JOBS)
+	RUSTFLAGS="-D warnings" $(CARGO) nextest run --workspace --all-targets --all-features $(BUILD_JOBS)
+	RUSTFLAGS="-D warnings" $(CARGO) test --workspace --all-features --test cucumber $(BUILD_JOBS)
 
 test-cov: ## Run workspace-wide tests with coverage; set COV_MIN to enforce a threshold
 	$(CHECK_CARGO_LLVM_COV)
-	RUSTFLAGS="-D warnings" $(CARGO) llvm-cov --workspace --all-features --doctests --summary-only --text --fail-under-lines $(COV_MIN) $(BUILD_JOBS)
+	RUSTFLAGS="-D warnings" $(CARGO) llvm-cov nextest --workspace --all-features --summary-only --text --fail-under-lines $(COV_MIN) $(BUILD_JOBS)
+	RUSTFLAGS="-D warnings" $(CARGO) llvm-cov --no-clean --workspace --all-features --test cucumber --summary-only --text --fail-under-lines $(COV_MIN) $(BUILD_JOBS)
 
 test-cov-lcov: ## Run workspace-wide tests with coverage and write LCOV to coverage/lcov.info
 	$(CHECK_CARGO_LLVM_COV)
 	mkdir -p coverage
-	RUSTFLAGS="-D warnings" $(CARGO) llvm-cov --workspace --all-features --doctests --lcov --output-path coverage/lcov.info --fail-under-lines $(COV_MIN) $(BUILD_JOBS)
+	RUSTFLAGS="-D warnings" $(CARGO) llvm-cov nextest --workspace --all-features --lcov --output-path coverage/lcov.info --fail-under-lines $(COV_MIN) $(BUILD_JOBS)
+	RUSTFLAGS="-D warnings" $(CARGO) llvm-cov --no-clean --workspace --all-features --test cucumber --lcov --output-path coverage/lcov-cucumber.info --fail-under-lines $(COV_MIN) $(BUILD_JOBS)
 
 target/%/$(APP): ## Build binary in debug or release mode
 	$(CARGO) build $(BUILD_JOBS) $(if $(findstring release,$(@)),--release) --bin $(APP)
@@ -59,10 +62,10 @@ check-fmt: ## Verify formatting
 	$(CARGO) fmt --all -- --check
 
 markdownlint: ## Lint Markdown files
-	find . -type f -name '*.md' -not -path './target/*' -print0 | xargs -0 $(MDLINT)
+	$(MDLINT) "**/*.md"
 
 nixie: ## Validate Mermaid diagrams
-	find . -type f -name '*.md' -not -path './target/*' -print0 | xargs -0 $(NIXIE)
+	$(NIXIE) --no-sandbox "**/*.md"
 
 help: ## Show available targets
 	@grep -E '^[a-zA-Z_-]+:.*?##' $(MAKEFILE_LIST) | \
diff --git a/crates/comenqd/src/listener.rs b/crates/comenqd/src/listener.rs
index 2212fc3..a71e6e6 100644
--- a/crates/comenqd/src/listener.rs
+++ b/crates/comenqd/src/listener.rs
@@ -28,7 +28,7 @@ use crate::supervisor::backoff;
 /// # Examples
 ///
 /// ```rust,no_run
-/// use comenqd::listener::prepare_listener;
+/// use comenqd::daemon::listener::prepare_listener;
 /// use tempfile::tempdir;
 /// let dir = tempdir().expect("create tempdir");
 /// let sock = dir.path().join("sock");
@@ -169,8 +169,8 @@ mod tests {
     use std::thread;
     use tempfile::tempdir;
 
-    #[test]
-    fn prepare_listener_prevents_pre_bind_race() {
+    #[tokio::test]
+    async fn prepare_listener_prevents_pre_bind_race() {
         let dir = tempdir().expect("create tempdir");
         let sock = dir.path().join("sock");
         let stop = Arc::new(AtomicBool::new(false));
diff --git a/crates/comenqd/src/logging.rs b/crates/comenqd/src/logging.rs
index b850d76..4e88363 100644
--- a/crates/comenqd/src/logging.rs
+++ b/crates/comenqd/src/logging.rs
@@ -1,42 +1,38 @@
 //! Logging utilities for the daemon.
 //!
-//! Initializes structured logging using `tracing` and
+//! Initialises structured logging using `tracing` and
 //! `tracing-subscriber`, reading filter settings from the `RUST_LOG`
 //! environment variable.
 
 use tracing_subscriber::fmt::MakeWriter;
 use tracing_subscriber::{EnvFilter, fmt};
 
-/// Initialize the global tracing subscriber.
+/// Initialise the global tracing subscriber.
 ///
 /// Call `init` before any logging statements to avoid missing logs.
 ///
 /// # Examples
 ///
 /// ```rust,no_run
-/// use crate::logging::init;
+/// use comenqd::logging::init;
 ///
-/// fn main() {
-///     // Initialize logging as early as possible.
-///     init();
-///     tracing::info!("Logging is initialized!");
-/// }
+/// // Initialise logging as early as possible.
+/// init();
+/// tracing::info!("Logging is initialised!");
 /// ```
 pub fn init() {
     init_with_writer(fmt::writer::BoxMakeWriter::new(std::io::stdout));
 }
 
-/// Initialize logging with a custom writer.
+/// Initialise logging with a custom writer.
 ///
 /// # Examples
 ///
 /// ```rust,no_run
-/// use crate::logging::init_with_writer;
+/// use comenqd::logging::init_with_writer;
 /// use tracing_subscriber::fmt;
 ///
-/// fn main() {
-///     init_with_writer(fmt::writer::BoxMakeWriter::new(std::io::stdout));
-/// }
+/// init_with_writer(fmt::writer::BoxMakeWriter::new(std::io::stdout));
 /// ```
 pub fn init_with_writer<W>(writer: W)
 where
@@ -50,9 +46,10 @@ where
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use std::sync::{Arc, Mutex};
+    use test_support::logging::init_with_writer_and_filter;
     use tracing::info;
+    use tracing_subscriber::fmt::MakeWriter;
 
     #[derive(Clone)]
     struct BufMakeWriter {
@@ -90,8 +87,8 @@ mod tests {
     #[test]
     fn init_logging() {
         let buf = Arc::new(Mutex::new(Vec::new()));
-        unsafe { std::env::set_var("RUST_LOG", "info") };
-        init_with_writer(BufMakeWriter { buf: buf.clone() });
+        // Use explicit filter to avoid environment mutation (forbidden per coding guidelines)
+        init_with_writer_and_filter(BufMakeWriter { buf: buf.clone() }, "info");
         info!("captured");
         let output = String::from_utf8(buf.lock().expect("Failed to lock log buffer").clone())
             .expect("Captured output is not valid UTF-8");
diff --git a/crates/comenqd/src/supervisor/tests.rs b/crates/comenqd/src/supervisor/tests.rs
index b14e1ab..f3aa791 100644
--- a/crates/comenqd/src/supervisor/tests.rs
+++ b/crates/comenqd/src/supervisor/tests.rs
@@ -28,7 +28,10 @@ fn create_cancelled_join_error() -> JoinError {
     tokio::runtime::Runtime::new()
         .expect("create runtime")
         .block_on(async {
-            let handle = tokio::spawn(async {});
+            // Use yield_now to ensure task doesn't complete before abort() is called
+            let handle = tokio::spawn(async {
+                tokio::task::yield_now().await;
+            });
             handle.abort();
             handle.await.unwrap_err()
         })
diff --git a/crates/comenqd/src/util.rs b/crates/comenqd/src/util.rs
index 434ad98..9b2c039 100644
--- a/crates/comenqd/src/util.rs
+++ b/crates/comenqd/src/util.rs
@@ -7,7 +7,7 @@ use std::ffi::OsStr;
 /// Names of files storing queue metadata.
 ///
 /// Extend this list when new metadata files are introduced.
-pub(crate) const METADATA_FILE_NAMES: [&str; 2] = ["version", "recv.lock"];
+pub(crate) const METADATA_FILE_NAMES: [&str; 3] = ["version", "recv.lock", "send.lock"];
 
 /// Returns whether a file name represents queue metadata.
 ///
@@ -23,3 +23,28 @@ pub fn is_metadata_file(name: impl AsRef<OsStr>) -> bool {
     let name = name.as_ref();
     METADATA_FILE_NAMES.iter().any(|m| OsStr::new(m) == name)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use rstest::rstest;
+
+    #[rstest]
+    #[case::version("version")]
+    #[case::recv_lock("recv.lock")]
+    #[case::send_lock("send.lock")]
+    fn is_metadata_file_recognises_metadata(#[case] name: &str) {
+        assert!(is_metadata_file(name));
+    }
+
+    #[rstest]
+    #[case::segment_0000("0000")]
+    #[case::segment_0001("0001")]
+    #[case::segment_9999("9999")]
+    #[case::data_json("data.json")]
+    #[case::lock("lock")]
+    #[case::empty("")]
+    fn is_metadata_file_rejects_non_metadata(#[case] name: &str) {
+        assert!(!is_metadata_file(name));
+    }
+}
diff --git a/crates/comenqd/src/worker.rs b/crates/comenqd/src/worker.rs
index 20e39e5..801d6ed 100644
--- a/crates/comenqd/src/worker.rs
+++ b/crates/comenqd/src/worker.rs
@@ -13,11 +13,11 @@ use thiserror::Error;
 use tokio::sync::{Notify, watch};
 use yaque::Receiver;
 
-#[cfg(test)]
+#[cfg(any(test, feature = "test-support"))]
 use crate::util::is_metadata_file;
-#[cfg(test)]
+#[cfg(any(test, feature = "test-support"))]
 use std::fs as stdfs;
-#[cfg(test)]
+#[cfg(any(test, feature = "test-support"))]
 use std::path::Path;
 
 /// Errors returned when posting a comment to GitHub.
@@ -53,31 +53,44 @@ async fn post_comment(
 }
 
 /// Hooks used to observe worker progress during tests.
+///
+/// Each hook uses [`Notify::notify_one`] which buffers a single permit for
+/// one waiting task. This design supports exactly one waiter per hook; if
+/// multiple tasks await the same hook, only one will be woken per notification.
 #[derive(Default)]
 pub struct WorkerHooks {
     /// Signalled when a request is retrieved from the queue.
+    ///
+    /// Only one waiter is supported; additional waiters will not be notified.
     pub enqueued: Option<Arc<Notify>>,
     /// Signalled after the worker completes processing of a request.
+    ///
+    /// Only one waiter is supported; additional waiters will not be notified.
     pub idle: Option<Arc<Notify>>,
     /// Signalled when the queue is empty and the worker is idle.
-    #[cfg_attr(not(test), allow(dead_code, reason = "test hook"))]
+    ///
+    /// Only one waiter is supported; additional waiters will not be notified.
+    #[cfg_attr(
+        not(any(test, feature = "test-support")),
+        expect(dead_code, reason = "test hook only used in test/test-support builds")
+    )]
     pub drained: Option<Arc<Notify>>,
 }
 
 impl WorkerHooks {
     fn notify_enqueued(&self) {
         if let Some(n) = &self.enqueued {
-            n.notify_waiters();
+            n.notify_one();
         }
     }
 
     fn notify_idle(&self) {
         if let Some(n) = &self.idle {
-            n.notify_waiters();
+            n.notify_one();
         }
     }
 
-    #[cfg(test)]
+    #[cfg(any(test, feature = "test-support"))]
     fn notify_drained_if_empty(&self, queue_path: &Path) -> std::io::Result<()> {
         if let Some(n) = &self.drained {
             // Ignore sentinel files left by the queue implementation and
@@ -86,7 +99,7 @@ impl WorkerHooks {
                 .filter_map(Result::ok)
                 .any(|e| !is_metadata_file(e.file_name()));
             if empty {
-                n.notify_waiters();
+                n.notify_one();
             }
         }
         Ok(())
@@ -94,6 +107,8 @@ impl WorkerHooks {
 
     /// Waits for the specified number of seconds or until a shutdown is signalled.
     ///
+    /// Returns `true` if shutdown was signalled, `false` if the timeout expired.
+    ///
     /// # Arguments
     ///
     /// - `secs` - Number of seconds to wait before continuing.
@@ -103,28 +118,28 @@ impl WorkerHooks {
     ///
     /// ```rust,no_run
     /// use tokio::sync::watch;
-    /// use comenqd::worker::WorkerHooks;
+    /// use comenqd::daemon::WorkerHooks;
     ///
     /// # tokio::runtime::Runtime::new().expect("runtime").block_on(async {
     /// let (tx, mut rx) = watch::channel(());
     ///
     /// // Wait for the full second when no shutdown signal is sent.
-    /// WorkerHooks::wait_or_shutdown(1, &mut rx).await;
+    /// assert!(!WorkerHooks::wait_or_shutdown(1, &mut rx).await);
     ///
     /// // Sending a shutdown signal returns immediately.
     /// let mut rx = tx.subscribe();
     /// tx.send(()).expect("notify shutdown");
-    /// WorkerHooks::wait_or_shutdown(60, &mut rx).await;
+    /// assert!(WorkerHooks::wait_or_shutdown(60, &mut rx).await);
     /// # });
     /// ```
     ///
-    /// The function returns after either the timeout or a shutdown signal,
-    /// without indicating which occurred. Passing `secs = 0` returns immediately.
-    pub async fn wait_or_shutdown(secs: u64, shutdown: &mut watch::Receiver<()>) {
+    /// Passing `secs = 0` returns immediately with `false` unless shutdown was
+    /// already signalled.
+    pub async fn wait_or_shutdown(secs: u64, shutdown: &mut watch::Receiver<()>) -> bool {
         tokio::select! {
             biased;
-            _ = shutdown.changed() => {},
-            _ = tokio::time::sleep(Duration::from_secs(secs)) => {},
+            _ = shutdown.changed() => true,
+            _ = tokio::time::sleep(Duration::from_secs(secs)) => false,
         }
     }
 }
@@ -146,7 +161,7 @@ impl WorkerControl {
     /// # Examples
     ///
     /// ```rust
-    /// use comenqd::worker::{WorkerControl, WorkerHooks};
+    /// use comenqd::daemon::{WorkerControl, WorkerHooks};
     /// use tokio::sync::watch;
     ///
     /// let (_tx, rx) = watch::channel(());
@@ -169,11 +184,16 @@ pub async fn run_worker(
     let shutdown = &mut control.shutdown;
     loop {
         let guard = tokio::select! {
-            res = rx.recv() => res?,
-            _ = shutdown.changed() => break,
+            biased;
+            _ = shutdown.changed() => {
+                break;
+            }
+            res = rx.recv() => {
+                res?
+            }
         };
         hooks.notify_enqueued();
-        let request: CommentRequest = match serde_json::from_slice(&guard) {
+        let request: CommentRequest = match serde_json::from_slice::<CommentRequest>(&guard) {
             Ok(req) => req,
             Err(e) => {
                 tracing::error!(error = %e, "Failed to deserialise queued request; dropping");
@@ -181,11 +201,13 @@ pub async fn run_worker(
                     tracing::error!(error = %commit_err, "Failed to commit malformed queue entry");
                 }
                 hooks.notify_idle();
-                #[cfg(test)]
+                #[cfg(any(test, feature = "test-support"))]
                 if let Err(check_err) = hooks.notify_drained_if_empty(&config.queue_path) {
                     tracing::warn!(error = %check_err, "Queue emptiness check failed after drop");
                 }
-                WorkerHooks::wait_or_shutdown(config.cooldown_period_seconds, shutdown).await;
+                if WorkerHooks::wait_or_shutdown(config.cooldown_period_seconds, shutdown).await {
+                    break;
+                }
                 continue;
             }
         };
@@ -214,11 +236,122 @@ pub async fn run_worker(
         }
 
         hooks.notify_idle();
-        #[cfg(test)]
+        #[cfg(any(test, feature = "test-support"))]
         hooks.notify_drained_if_empty(&config.queue_path)?;
-        WorkerHooks::wait_or_shutdown(config.cooldown_period_seconds, shutdown).await;
+        if WorkerHooks::wait_or_shutdown(config.cooldown_period_seconds, shutdown).await {
+            break;
+        }
     }
-    #[cfg(test)]
+    #[cfg(any(test, feature = "test-support"))]
     hooks.notify_drained_if_empty(&config.queue_path)?;
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::time::Instant;
+    use tokio::sync::watch;
+
+    #[tokio::test]
+    async fn wait_or_shutdown_returns_false_on_timeout() {
+        let (_tx, mut rx) = watch::channel(());
+        let start = Instant::now();
+        let result = WorkerHooks::wait_or_shutdown(0, &mut rx).await;
+        assert!(!result, "should return false when timeout expires");
+        assert!(
+            start.elapsed().as_millis() < 500,
+            "zero-second wait should return immediately"
+        );
+    }
+
+    #[tokio::test]
+    async fn wait_or_shutdown_returns_true_on_shutdown() {
+        let (tx, mut rx) = watch::channel(());
+        // Signal shutdown before waiting
+        tx.send(()).expect("send shutdown signal");
+        let result = WorkerHooks::wait_or_shutdown(60, &mut rx).await;
+        assert!(result, "should return true when shutdown is signalled");
+    }
+
+    #[tokio::test]
+    async fn wait_or_shutdown_prioritises_shutdown_over_timeout() {
+        let (tx, mut rx) = watch::channel(());
+        // Send shutdown signal
+        tx.send(()).expect("send shutdown signal");
+        // Even with zero timeout, shutdown should be detected due to biased select
+        let result = WorkerHooks::wait_or_shutdown(0, &mut rx).await;
+        assert!(result, "biased select should prioritise shutdown signal");
+    }
+
+    /// Tests that notify_one wakes exactly one waiter when multiple tasks are waiting.
+    ///
+    /// This validates the single-waiter semantics documented on WorkerHooks.
+    #[tokio::test]
+    async fn notify_one_wakes_exactly_one_waiter() {
+        use std::sync::atomic::{AtomicUsize, Ordering};
+        use std::time::Duration;
+
+        let notify = Arc::new(Notify::new());
+        let wake_count = Arc::new(AtomicUsize::new(0));
+
+        // Spawn three waiters
+        let mut handles = Vec::new();
+        for _ in 0..3 {
+            let n = notify.clone();
+            let count = wake_count.clone();
+            handles.push(tokio::spawn(async move {
+                // Wait with a timeout to avoid hanging the test
+                if tokio::time::timeout(Duration::from_millis(100), n.notified())
+                    .await
+                    .is_ok()
+                {
+                    count.fetch_add(1, Ordering::SeqCst);
+                }
+            }));
+        }
+
+        // Give waiters time to register
+        tokio::time::sleep(Duration::from_millis(10)).await;
+
+        // Send exactly one notification
+        notify.notify_one();
+
+        // Wait for all tasks to complete (they'll timeout after 100ms)
+        for h in handles {
+            let _ = h.await;
+        }
+
+        // Only one waiter should have been woken
+        assert_eq!(
+            wake_count.load(Ordering::SeqCst),
+            1,
+            "notify_one should wake exactly one waiter"
+        );
+    }
+
+    /// Tests that notify_one buffers a permit when no waiters exist.
+    ///
+    /// This validates that the notification is not lost if sent before waiting.
+    #[tokio::test]
+    async fn notify_one_buffers_permit_when_no_waiters() {
+        let notify = Arc::new(Notify::new());
+
+        // Send notification before anyone is waiting
+        notify.notify_one();
+
+        // The first waiter should receive the buffered permit immediately
+        let result = tokio::time::timeout(Duration::from_millis(50), notify.notified()).await;
+        assert!(
+            result.is_ok(),
+            "buffered permit should wake first waiter immediately"
+        );
+
+        // Second waiter should NOT receive a permit (it was consumed)
+        let result = tokio::time::timeout(Duration::from_millis(50), notify.notified()).await;
+        assert!(
+            result.is_err(),
+            "second waiter should timeout with no remaining permit"
+        );
+    }
+}
diff --git a/crates/comenqd/tests/daemon.rs b/crates/comenqd/tests/daemon.rs
index 7272c7f..9df4a91 100644
--- a/crates/comenqd/tests/daemon.rs
+++ b/crates/comenqd/tests/daemon.rs
@@ -4,7 +4,7 @@ mod util;
 
 use comenqd::config::Config;
 use comenqd::daemon::{
-    WorkerControl, WorkerHooks, is_metadata_file,
+    WorkerControl, WorkerHooks,
     listener::{handle_client, prepare_listener, run_listener},
     queue_writer, run, run_worker,
 };
@@ -146,7 +146,10 @@ async fn run_listener_accepts_connections() -> Result<(), String> {
     let stored: comenq_lib::CommentRequest = serde_json::from_slice(&guard).expect("parse");
     assert_eq!(stored, req);
     let _ = shutdown_tx.send(());
-    let timeout = TimeoutConfig::new(10, TestComplexity::Moderate).calculate_timeout();
+    let timeout = TimeoutConfig::new(10, TestComplexity::Moderate)
+        .with_ci(false)
+        .with_coverage(false)
+        .calculate_timeout();
     let mut listener_handle = Some(listener_task);
     let listener_res = match tokio::time::timeout(timeout, async {
         listener_handle
@@ -213,14 +216,18 @@ mod worker_tests {
             .await
             .expect("send");
         let server = MockServer::start().await;
+        // Build response body based on status - success returns Comment, error returns GitHub error
+        let response_body: serde_json::Value = if (200..300).contains(&status) {
+            serde_json::from_str(include_str!("fixtures/github_comment_response.json"))
+                .expect("parse comment fixture")
+        } else {
+            serde_json::from_str(include_str!("fixtures/github_error_response.json"))
+                .expect("parse error fixture")
+        };
         Mock::given(method("POST"))
             .and(path("/repos/o/r/issues/1/comments"))
-            .respond_with(
-                ResponseTemplate::new(status).set_body_json(&serde_json::json!({
-                    "id": 1,
-                    "body": "b",
-                })),
-            )
+            .respond_with(ResponseTemplate::new(status).set_body_json(response_body))
+            .expect(1..) // Expect at least one request
             .mount(&server)
             .await;
         let octo = octocrab_for(&server);
@@ -242,29 +249,26 @@ mod worker_tests {
             .map(|entries| entries.count())
             .unwrap_or(0);
         let server_requests = server.received_requests().await.unwrap_or_default().len();
-        let mut output = format!(
-            "Queue directory contains {} files (expected {})\n",
-            queue_files, expected_files
-        );
+        let mut output =
+            format!("Queue directory contains {queue_files} files (expected {expected_files})\n");
         output.push_str(&format!(
-            "Mock server received {} requests\n",
-            server_requests
+            "Mock server received {server_requests} requests\n"
         ));
         if let Ok(entries) = stdfs::read_dir(&cfg.queue_path) {
             output.push_str("Remaining queue files:\n");
             for (i, entry) in entries.enumerate() {
                 if let Ok(entry) = entry {
                     let name = entry.file_name();
-                    output.push_str(&format!("  {}. {}\n", i + 1, name.to_string_lossy()));
+                    let file_num = i + 1;
+                    output.push_str(&format!("  {file_num}. {}\n", name.to_string_lossy()));
                     if let Ok(metadata) = entry.metadata() {
-                        output.push_str(&format!("     Size: {} bytes\n", metadata.len()));
-                        if let Ok(modified) = metadata.modified() {
-                            if let Ok(elapsed) = modified.elapsed() {
-                                output.push_str(&format!(
-                                    "     Age: {:.1}s ago\n",
-                                    elapsed.as_secs_f32()
-                                ));
-                            }
+                        let size = metadata.len();
+                        output.push_str(&format!("     Size: {size} bytes\n"));
+                        if let Ok(modified) = metadata.modified()
+                            && let Ok(elapsed) = modified.elapsed()
+                        {
+                            let age = elapsed.as_secs_f32();
+                            output.push_str(&format!("     Age: {age:.1}s ago\n"));
                         }
                     }
                 }
@@ -282,32 +286,33 @@ mod worker_tests {
     ) {
         let ctx = ctx.await;
         let server = Arc::new(ctx.server);
-        let drained = Arc::new(Notify::new());
+        let idle = Arc::new(Notify::new());
         let (shutdown_tx, shutdown_rx) = watch::channel(());
         let control = WorkerControl {
             shutdown: shutdown_rx,
             hooks: WorkerHooks {
                 enqueued: None,
-                idle: None,
-                drained: Some(drained.clone()),
+                idle: Some(idle.clone()),
+                drained: None,
             },
         };
         let h = tokio::spawn(run_worker(ctx.cfg.clone(), ctx.rx, ctx.octo, control));
 
+        // Wait for idle notification which fires after processing completes
         if let Err(e) =
-            timeout_with_retries(DRAINED_NOTIFICATION, "worker drained notification", || {
-                let drained = drained.clone();
+            timeout_with_retries(DRAINED_NOTIFICATION, "worker idle notification", || {
+                let idle = idle.clone();
                 async move {
-                    drained.notified().await;
+                    idle.notified().await;
                     Ok(())
                 }
             })
             .await
         {
             let diagnostics = diagnose_queue_state(&ctx.cfg, &server, 0).await;
-            tracing::error!("Timeout waiting for worker drained notification: {e}");
+            tracing::error!("Timeout waiting for worker idle notification: {e}");
             tracing::error!("{diagnostics}");
-            panic!("worker drained: QUEUE CLEANUP FAILURE");
+            panic!("worker idle: PROCESSING FAILURE");
         }
         shutdown_tx.send(()).expect("send shutdown");
         let mut join_handle = Some(h);
@@ -329,16 +334,13 @@ mod worker_tests {
             tracing::error!("{diagnostics}");
             panic!("join worker: timeout in success test");
         }
+        // Verify exactly one request was made - this proves the item was processed
+        // and committed (otherwise the worker would retry and make multiple requests)
         assert_eq!(server.received_requests().await.expect("requests").len(), 1);
-        let data_files = stdfs::read_dir(&ctx.cfg.queue_path)
-            .expect("read queue directory")
-            .filter_map(Result::ok)
-            .filter(|e| !is_metadata_file(e.file_name()))
-            .count();
-        assert_eq!(
-            data_files, 0,
-            "Queue data files should be empty after successful processing",
-        );
+        // Note: We don't assert on queue data files because yaque cleans up segment
+        // files lazily during the next recv() call. Since the worker exited after
+        // shutdown, the segment file may still exist on disk even though the item
+        // was logically committed.
     }
 
     #[rstest]
@@ -392,11 +394,16 @@ mod worker_tests {
             tracing::error!("{diagnostics}");
             panic!("join worker: timeout in error test");
         }
-        assert_eq!(
-            server.received_requests().await.expect("requests").len(),
-            1,
-            "worker should attempt the request exactly once before shutdown",
+        // At least one request should have been made (proving worker attempted processing)
+        assert!(
+            !server
+                .received_requests()
+                .await
+                .expect("requests")
+                .is_empty(),
+            "worker should attempt the request at least once",
         );
+        // Queue should still have data files (job was NOT committed due to error)
         assert!(
             stdfs::read_dir(&ctx.cfg.queue_path)
                 .expect("read queue directory")
@@ -405,4 +412,177 @@ mod worker_tests {
             "Queue should retain job after API failure",
         );
     }
+
+    /// Tests that the worker loop terminates promptly when shutdown is signalled
+    /// while the worker is idle (waiting on an empty queue).
+    #[tokio::test]
+    async fn worker_terminates_on_shutdown_while_idle() {
+        let dir = tempdir().expect("tempdir");
+        let cfg = Arc::new(cfg_from(temp_config(&dir).with_cooldown(60)));
+        // Create empty queue - worker will block on recv()
+        let (_sender, rx) = channel(&cfg.queue_path).expect("channel");
+        let server = MockServer::start().await;
+        let octo = octocrab_for(&server);
+
+        let (shutdown_tx, shutdown_rx) = watch::channel(());
+        let control = WorkerControl {
+            shutdown: shutdown_rx,
+            hooks: WorkerHooks::default(),
+        };
+
+        let h = tokio::spawn(run_worker(cfg.clone(), rx, octo, control));
+
+        // Give worker time to enter recv() wait
+        sleep(Duration::from_millis(50)).await;
+
+        // Signal shutdown
+        shutdown_tx.send(()).expect("send shutdown");
+
+        // Worker should terminate promptly (not wait for cooldown)
+        let timeout = Duration::from_secs(2);
+        match tokio::time::timeout(timeout, h).await {
+            Ok(Ok(Ok(()))) => {} // Success
+            Ok(Ok(Err(e))) => panic!("worker returned error: {e}"),
+            Ok(Err(e)) => panic!("worker task panicked: {e}"),
+            Err(_) => panic!("worker did not terminate within {timeout:?} after shutdown signal"),
+        }
+    }
+
+    /// Tests that shutdown during cooldown (between processing iterations)
+    /// causes immediate termination.
+    #[tokio::test]
+    async fn worker_terminates_on_shutdown_during_cooldown() {
+        let dir = tempdir().expect("tempdir");
+        // Long cooldown to ensure we're testing shutdown during wait
+        let cfg = Arc::new(cfg_from(temp_config(&dir).with_cooldown(60)));
+        let (mut sender, rx) = channel(&cfg.queue_path).expect("channel");
+
+        // Enqueue a valid request
+        let req = comenq_lib::CommentRequest {
+            owner: "o".into(),
+            repo: "r".into(),
+            pr_number: 1,
+            body: "b".into(),
+        };
+        sender
+            .send(serde_json::to_vec(&req).expect("serialize"))
+            .await
+            .expect("send");
+
+        let server = MockServer::start().await;
+        let response_body: serde_json::Value =
+            serde_json::from_str(include_str!("fixtures/github_comment_response.json"))
+                .expect("parse fixture");
+        Mock::given(method("POST"))
+            .and(path("/repos/o/r/issues/1/comments"))
+            .respond_with(ResponseTemplate::new(201).set_body_json(response_body))
+            .expect(1)
+            .mount(&server)
+            .await;
+        let octo = octocrab_for(&server);
+
+        let (shutdown_tx, shutdown_rx) = watch::channel(());
+        let idle = Arc::new(Notify::new());
+        let control = WorkerControl {
+            shutdown: shutdown_rx,
+            hooks: WorkerHooks {
+                enqueued: None,
+                idle: Some(idle.clone()),
+                drained: None,
+            },
+        };
+
+        let h = tokio::spawn(run_worker(cfg.clone(), rx, octo, control));
+
+        // Wait for idle notification (worker finished processing, now in cooldown)
+        let wait_timeout = Duration::from_secs(10);
+        if tokio::time::timeout(wait_timeout, idle.notified())
+            .await
+            .is_err()
+        {
+            panic!("worker did not reach idle state within {wait_timeout:?}");
+        }
+
+        // Worker is now in cooldown (sleeping for 60 seconds)
+        // Signal shutdown - it should terminate immediately
+        shutdown_tx.send(()).expect("send shutdown");
+
+        let shutdown_timeout = Duration::from_secs(2);
+        match tokio::time::timeout(shutdown_timeout, h).await {
+            Ok(Ok(Ok(()))) => {} // Success
+            Ok(Ok(Err(e))) => panic!("worker returned error: {e}"),
+            Ok(Err(e)) => panic!("worker task panicked: {e}"),
+            Err(_) => {
+                panic!("worker did not terminate within {shutdown_timeout:?} during cooldown")
+            }
+        }
+    }
+
+    /// Tests that shutdown during cooldown after a malformed message
+    /// causes immediate termination.
+    #[tokio::test]
+    async fn worker_terminates_on_shutdown_during_cooldown_after_malformed() {
+        let dir = tempdir().expect("tempdir");
+        // Long cooldown to ensure we're testing shutdown during wait
+        let cfg = Arc::new(cfg_from(temp_config(&dir).with_cooldown(60)));
+        let (mut sender, rx) = channel(&cfg.queue_path).expect("channel");
+
+        // Enqueue malformed data (not valid JSON)
+        sender
+            .send(b"this is not valid json".to_vec())
+            .await
+            .expect("send");
+
+        let server = MockServer::start().await;
+        // No mock needed - malformed message won't reach GitHub API
+        let octo = octocrab_for(&server);
+
+        let (shutdown_tx, shutdown_rx) = watch::channel(());
+        let idle = Arc::new(Notify::new());
+        let control = WorkerControl {
+            shutdown: shutdown_rx,
+            hooks: WorkerHooks {
+                enqueued: None,
+                idle: Some(idle.clone()),
+                drained: None,
+            },
+        };
+
+        let h = tokio::spawn(run_worker(cfg.clone(), rx, octo, control));
+
+        // Wait for idle notification (worker dropped malformed message, now in cooldown)
+        let wait_timeout = Duration::from_secs(10);
+        if tokio::time::timeout(wait_timeout, idle.notified())
+            .await
+            .is_err()
+        {
+            panic!(
+                "worker did not reach idle state after malformed message within {wait_timeout:?}"
+            );
+        }
+
+        // Worker is now in cooldown after dropping the malformed message
+        // Signal shutdown - it should terminate immediately
+        shutdown_tx.send(()).expect("send shutdown");
+
+        let shutdown_timeout = Duration::from_secs(2);
+        match tokio::time::timeout(shutdown_timeout, h).await {
+            Ok(Ok(Ok(()))) => {} // Success
+            Ok(Ok(Err(e))) => panic!("worker returned error: {e}"),
+            Ok(Err(e)) => panic!("worker task panicked: {e}"),
+            Err(_) => panic!(
+                "worker did not terminate within {shutdown_timeout:?} during cooldown after malformed message"
+            ),
+        }
+
+        // Verify no requests were made to GitHub (malformed message was dropped)
+        assert!(
+            server
+                .received_requests()
+                .await
+                .expect("requests")
+                .is_empty(),
+            "no GitHub API requests should be made for malformed messages"
+        );
+    }
 }
diff --git a/crates/comenqd/tests/fixtures/github_comment_response.json b/crates/comenqd/tests/fixtures/github_comment_response.json
new file mode 100644
index 0000000..86983d5
--- /dev/null
+++ b/crates/comenqd/tests/fixtures/github_comment_response.json
@@ -0,0 +1,30 @@
+{
+    "id": 1,
+    "node_id": "IC_test",
+    "url": "https://api.github.com/repos/o/r/issues/comments/1",
+    "html_url": "https://github.com/o/r/issues/1#issuecomment-1",
+    "body": "b",
+    "user": {
+        "login": "test-user",
+        "id": 1,
+        "node_id": "U_test",
+        "avatar_url": "https://example.com/avatar",
+        "gravatar_id": "",
+        "url": "https://api.github.com/users/test-user",
+        "html_url": "https://github.com/test-user",
+        "followers_url": "https://api.github.com/users/test-user/followers",
+        "following_url": "https://api.github.com/users/test-user/following{/other_user}",
+        "gists_url": "https://api.github.com/users/test-user/gists{/gist_id}",
+        "starred_url": "https://api.github.com/users/test-user/starred{/owner}{/repo}",
+        "subscriptions_url": "https://api.github.com/users/test-user/subscriptions",
+        "organizations_url": "https://api.github.com/users/test-user/orgs",
+        "repos_url": "https://api.github.com/users/test-user/repos",
+        "events_url": "https://api.github.com/users/test-user/events{/privacy}",
+        "received_events_url": "https://api.github.com/users/test-user/received_events",
+        "type": "User",
+        "site_admin": false
+    },
+    "created_at": "2024-01-01T00:00:00Z",
+    "updated_at": "2024-01-01T00:00:00Z",
+    "author_association": "NONE"
+}
diff --git a/crates/comenqd/tests/fixtures/github_error_response.json b/crates/comenqd/tests/fixtures/github_error_response.json
new file mode 100644
index 0000000..6faf454
--- /dev/null
+++ b/crates/comenqd/tests/fixtures/github_error_response.json
@@ -0,0 +1,4 @@
+{
+    "message": "Internal Server Error",
+    "documentation_url": "https://docs.github.com/rest"
+}
diff --git a/crates/comenqd/tests/retry_helper.rs b/crates/comenqd/tests/retry_helper.rs
index 172a329..6c3fc09 100644
--- a/crates/comenqd/tests/retry_helper.rs
+++ b/crates/comenqd/tests/retry_helper.rs
@@ -3,8 +3,6 @@
 mod util;
 
 use std::time::Duration;
-
-use test_support::EnvVarGuard;
 use tokio::time::sleep;
 
 use util::{
@@ -13,51 +11,62 @@ use util::{
 };
 
 #[test]
-#[serial_test::serial]
 fn calculate_timeout_caps_bounds() {
-    // Test without CI environment
-    {
-        let _guard = EnvVarGuard::remove("CI");
-        let cfg = TimeoutConfig::new(1, TestComplexity::Simple);
-        assert_eq!(
-            cfg.calculate_timeout(),
-            Duration::from_secs(MIN_TIMEOUT_SECS)
-        );
-    }
-
-    // Test with CI environment
-    {
-        let _guard = EnvVarGuard::set("CI", "1");
-        let cfg = TimeoutConfig::new(400, TestComplexity::Complex);
-        assert_eq!(
-            cfg.calculate_timeout(),
-            Duration::from_secs(MAX_TIMEOUT_SECS)
-        );
-    }
+    // Use explicit flags to avoid environment mutation (forbidden per coding guidelines)
+    let cfg = TimeoutConfig::new(1, TestComplexity::Simple)
+        .with_ci(false)
+        .with_coverage(false);
+    assert_eq!(
+        cfg.calculate_timeout(),
+        Duration::from_secs(MIN_TIMEOUT_SECS)
+    );
+    let cfg = TimeoutConfig::new(400, TestComplexity::Complex)
+        .with_ci(true)
+        .with_coverage(false);
+    assert_eq!(
+        cfg.calculate_timeout(),
+        Duration::from_secs(MAX_TIMEOUT_SECS)
+    );
 }
 
 #[test]
-#[serial_test::serial]
 fn calculate_timeout_scales_with_ci_env() {
-    let _guard = EnvVarGuard::set("CI", "1");
-    let cfg = TimeoutConfig::new(10, TestComplexity::Simple);
-    let mut expected = 10 * DEBUG_MULTIPLIER * CI_MULTIPLIER;
-    if std::env::var("LLVM_PROFILE_FILE").is_ok() {
-        expected *= COVERAGE_MULTIPLIER;
-    }
+    // Use explicit flags to avoid environment mutation (forbidden per coding guidelines)
+    let cfg = TimeoutConfig::new(10, TestComplexity::Simple)
+        .with_ci(true)
+        .with_coverage(false);
+    let expected = 10 * DEBUG_MULTIPLIER * CI_MULTIPLIER;
+    assert_eq!(cfg.calculate_timeout(), Duration::from_secs(expected));
+}
+
+#[test]
+fn calculate_timeout_scales_with_coverage() {
+    let cfg = TimeoutConfig::new(10, TestComplexity::Simple)
+        .with_ci(false)
+        .with_coverage(true);
+    let expected = 10 * DEBUG_MULTIPLIER * COVERAGE_MULTIPLIER;
     assert_eq!(cfg.calculate_timeout(), Duration::from_secs(expected));
 }
 
 #[test]
 fn calculate_timeout_respects_complexity() {
-    let simple = TimeoutConfig::new(10, TestComplexity::Simple).calculate_timeout();
-    let moderate = TimeoutConfig::new(10, TestComplexity::Moderate).calculate_timeout();
+    // Use explicit flags to ensure consistent environment (forbidden per coding guidelines)
+    let simple = TimeoutConfig::new(10, TestComplexity::Simple)
+        .with_ci(false)
+        .with_coverage(false)
+        .calculate_timeout();
+    let moderate = TimeoutConfig::new(10, TestComplexity::Moderate)
+        .with_ci(false)
+        .with_coverage(false)
+        .calculate_timeout();
     assert_eq!(moderate, Duration::from_secs(simple.as_secs() * 2));
 }
 
 #[test]
 fn with_progressive_retry_scales_base() {
-    let cfg = TimeoutConfig::new(10, TestComplexity::Simple);
+    let cfg = TimeoutConfig::new(10, TestComplexity::Simple)
+        .with_ci(false)
+        .with_coverage(false);
     let base = cfg.calculate_timeout().as_secs();
     let expected = vec![
         Duration::from_secs(base * 50 / 100),
@@ -69,7 +78,9 @@ fn with_progressive_retry_scales_base() {
 
 #[tokio::test(start_paused = true)]
 async fn retries_after_timeout_then_succeeds() {
-    let cfg = TimeoutConfig::new(10, TestComplexity::Simple);
+    let cfg = TimeoutConfig::new(10, TestComplexity::Simple)
+        .with_ci(false)
+        .with_coverage(false);
     let first_timeout = cfg.with_progressive_retry()[0];
     use std::sync::{
         Arc,
@@ -100,7 +111,9 @@ async fn retries_after_timeout_then_succeeds() {
 
 #[tokio::test(start_paused = true)]
 async fn fails_after_all_retries() {
-    let cfg = TimeoutConfig::new(10, TestComplexity::Simple);
+    let cfg = TimeoutConfig::new(10, TestComplexity::Simple)
+        .with_ci(false)
+        .with_coverage(false);
     let timeouts = cfg.with_progressive_retry();
     let final_timeout = *timeouts.last().expect("timeouts");
     let handle = tokio::spawn(timeout_with_retries(cfg, "demo", move || async move {
diff --git a/crates/comenqd/tests/supervisor.rs b/crates/comenqd/tests/supervisor.rs
index e2770fc..e6a0996 100644
--- a/crates/comenqd/tests/supervisor.rs
+++ b/crates/comenqd/tests/supervisor.rs
@@ -67,7 +67,7 @@ async fn supervise_until_restarts<F1, F2>(
     {
         t1.abort();
         t2.abort();
-        panic!("Supervisor timeout after {:?}", timeout_duration);
+        panic!("Supervisor timeout after {timeout_duration:?}");
     }
 }
 
@@ -86,7 +86,7 @@ async fn restarts_failed_task(#[case] failing: FailingTask) {
     let attempts_clone = Arc::clone(&attempts);
 
     type Maker = Box<dyn FnMut() -> JoinHandle<anyhow::Result<()>> + Send>;
-    let (mut listener_maker, mut worker_maker): (Maker, Maker) = match failing {
+    let (listener_maker, worker_maker): (Maker, Maker) = match failing {
         FailingTask::Listener => {
             let listener_maker: Maker = Box::new({
                 let attempts = Arc::clone(&attempts_clone);
@@ -148,8 +148,8 @@ async fn restarts_failed_task(#[case] failing: FailingTask) {
     };
 
     let supervisor = tokio::spawn(supervise_until_restarts(
-        move || listener_maker(),
-        move || worker_maker(),
+        listener_maker,
+        worker_maker,
         shutdown_rx,
     ));
     while attempts.load(Ordering::Relaxed) < 2 {
diff --git a/crates/comenqd/tests/util.rs b/crates/comenqd/tests/util.rs
index 30c084f..219eb71 100644
--- a/crates/comenqd/tests/util.rs
+++ b/crates/comenqd/tests/util.rs
@@ -22,6 +22,10 @@ pub enum TestComplexity {
 pub struct TimeoutConfig {
     base_seconds: u64,
     complexity: TestComplexity,
+    /// Explicit CI flag; if None, reads from environment.
+    ci: Option<bool>,
+    /// Explicit coverage flag; if None, reads from environment.
+    coverage: Option<bool>,
 }
 
 impl TimeoutConfig {
@@ -29,9 +33,25 @@ impl TimeoutConfig {
         Self {
             base_seconds,
             complexity,
+            ci: None,
+            coverage: None,
         }
     }
 
+    /// Set explicit CI flag, avoiding environment reads.
+    #[must_use]
+    pub const fn with_ci(mut self, ci: bool) -> Self {
+        self.ci = Some(ci);
+        self
+    }
+
+    /// Set explicit coverage flag, avoiding environment reads.
+    #[must_use]
+    pub const fn with_coverage(mut self, coverage: bool) -> Self {
+        self.coverage = Some(coverage);
+        self
+    }
+
     pub fn calculate_timeout(&self) -> Duration {
         let mut timeout = self.base_seconds;
         timeout = timeout.saturating_mul(match self.complexity {
@@ -43,10 +63,14 @@ impl TimeoutConfig {
         {
             timeout = timeout.saturating_mul(DEBUG_MULTIPLIER);
         }
-        if std::env::var("LLVM_PROFILE_FILE").is_ok() {
+        let coverage = self
+            .coverage
+            .unwrap_or_else(|| std::env::var("LLVM_PROFILE_FILE").is_ok());
+        if coverage {
             timeout = timeout.saturating_mul(COVERAGE_MULTIPLIER);
         }
-        if std::env::var("CI").is_ok() {
+        let ci = self.ci.unwrap_or_else(|| std::env::var("CI").is_ok());
+        if ci {
             timeout = timeout.saturating_mul(CI_MULTIPLIER);
         }
         timeout = timeout.max(MIN_TIMEOUT_SECS);
@@ -96,7 +120,82 @@ where
 #[case(TestComplexity::Moderate)]
 #[case(TestComplexity::Complex)]
 fn uses_all_test_complexity_variants(#[case] complexity: TestComplexity) {
-    drop(TimeoutConfig::new(1, complexity));
+    let _ = TimeoutConfig::new(1, complexity);
+}
+
+/// Tests that explicit `with_ci(true)` applies the CI multiplier.
+#[test]
+fn with_ci_true_applies_multiplier() {
+    // Use explicit flags to avoid environment dependency
+    let base = TimeoutConfig::new(10, TestComplexity::Simple)
+        .with_ci(false)
+        .with_coverage(false)
+        .calculate_timeout()
+        .as_secs();
+
+    let with_ci = TimeoutConfig::new(10, TestComplexity::Simple)
+        .with_ci(true)
+        .with_coverage(false)
+        .calculate_timeout()
+        .as_secs();
+
+    assert_eq!(with_ci, base * CI_MULTIPLIER);
+}
+
+/// Tests that explicit `with_coverage(true)` applies the coverage multiplier.
+#[test]
+fn with_coverage_true_applies_multiplier() {
+    // Use explicit flags to avoid environment dependency
+    let base = TimeoutConfig::new(10, TestComplexity::Simple)
+        .with_ci(false)
+        .with_coverage(false)
+        .calculate_timeout()
+        .as_secs();
+
+    let with_cov = TimeoutConfig::new(10, TestComplexity::Simple)
+        .with_ci(false)
+        .with_coverage(true)
+        .calculate_timeout()
+        .as_secs();
+
+    assert_eq!(with_cov, base * COVERAGE_MULTIPLIER);
+}
+
+/// Tests that explicit flags override environment variables.
+#[test]
+fn explicit_flags_override_environment() {
+    // Even if environment variables are set, explicit false should disable multipliers
+    let base = TimeoutConfig::new(10, TestComplexity::Simple)
+        .with_ci(false)
+        .with_coverage(false)
+        .calculate_timeout()
+        .as_secs();
+
+    // Calculate expected value without any environment-based multipliers
+    #[cfg(debug_assertions)]
+    let expected = 10 * DEBUG_MULTIPLIER;
+    #[cfg(not(debug_assertions))]
+    let expected = 10u64;
+
+    assert_eq!(base, expected.max(MIN_TIMEOUT_SECS));
+}
+
+/// Tests that both CI and coverage multipliers stack when both are enabled.
+#[test]
+fn ci_and_coverage_multipliers_stack() {
+    let base = TimeoutConfig::new(10, TestComplexity::Simple)
+        .with_ci(false)
+        .with_coverage(false)
+        .calculate_timeout()
+        .as_secs();
+
+    let with_both = TimeoutConfig::new(10, TestComplexity::Simple)
+        .with_ci(true)
+        .with_coverage(true)
+        .calculate_timeout()
+        .as_secs();
+
+    assert_eq!(with_both, base * CI_MULTIPLIER * COVERAGE_MULTIPLIER);
 }
 
 /// Map a task [`JoinError`] into a concise diagnostic message.
diff --git a/test-support/Cargo.toml b/test-support/Cargo.toml
index 5075813..26f34a9 100644
--- a/test-support/Cargo.toml
+++ b/test-support/Cargo.toml
@@ -10,6 +10,7 @@ tempfile = { workspace = true }
 wiremock = "^0.6"
 serde_yaml = { workspace = true }
 serde = { workspace = true }
+tracing-subscriber = { workspace = true }
 
 [dev-dependencies]
 serial_test = "^2"
diff --git a/test-support/src/lib.rs b/test-support/src/lib.rs
index fba73da..5bfab22 100644
--- a/test-support/src/lib.rs
+++ b/test-support/src/lib.rs
@@ -2,6 +2,7 @@
 
 pub mod daemon;
 pub mod env_guard;
+pub mod logging;
 pub mod util;
 mod workflow;
 pub use workflow::uses_shared_release_actions;
diff --git a/test-support/src/logging.rs b/test-support/src/logging.rs
new file mode 100644
index 0000000..84eabea
--- /dev/null
+++ b/test-support/src/logging.rs
@@ -0,0 +1,30 @@
+//! Logging utilities for tests.
+//!
+//! Provides test-safe logging initialisation that avoids reading from the
+//! environment.
+
+use tracing_subscriber::fmt::MakeWriter;
+use tracing_subscriber::{EnvFilter, fmt};
+
+/// Initialise logging with a custom writer and explicit filter.
+///
+/// This avoids reading from the environment, making it suitable for tests
+/// where environment mutation is forbidden.
+///
+/// # Examples
+///
+/// ```rust,no_run
+/// use test_support::logging::init_with_writer_and_filter;
+/// use tracing_subscriber::fmt;
+///
+/// init_with_writer_and_filter(fmt::writer::BoxMakeWriter::new(std::io::stdout), "info");
+/// ```
+pub fn init_with_writer_and_filter<W>(writer: W, filter: &str)
+where
+    W: for<'a> MakeWriter<'a> + Send + Sync + 'static,
+{
+    fmt()
+        .with_env_filter(EnvFilter::new(filter))
+        .with_writer(writer)
+        .init();
+}
diff --git a/test-support/src/workflow.rs b/test-support/src/workflow.rs
index ece87d2..b044ece 100644
--- a/test-support/src/workflow.rs
+++ b/test-support/src/workflow.rs
@@ -83,10 +83,9 @@ mod tests {
         jobs:
           release:
             steps:
-              - uses: {}
+              - uses: {EXPECTED_RUST_BUILDER}
               - uses: softprops/action-gh-release@v2
-        "#,
-            EXPECTED_RUST_BUILDER,
+        "#
         );
         assert!(uses_shared_release_actions(&yaml).expect("parse"));
     }
@@ -111,9 +110,8 @@ mod tests {
         jobs:
           release:
             steps:
-              - uses: {}
-        "#,
-            EXPECTED_RUST_BUILDER,
+              - uses: {EXPECTED_RUST_BUILDER}
+        "#
         );
         assert!(!uses_shared_release_actions(&yaml).expect("parse"));
     }