diff --git a/backend/graph-proxy/src/graphql/filters.rs b/backend/graph-proxy/src/graphql/filters.rs
index d63024bbb..33fa21c39 100644
--- a/backend/graph-proxy/src/graphql/filters.rs
+++ b/backend/graph-proxy/src/graphql/filters.rs
@@ -1,5 +1,6 @@
 use std::collections::HashSet;
 
+use argo_workflows_openapi::IoArgoprojWorkflowV1alpha1Workflow;
 use async_graphql::{
     Enum, InputObject, InputValueError, InputValueResult, Scalar, ScalarType, Value,
 };
@@ -114,7 +115,6 @@ pub enum WorkflowLabelSelectorOperator {
 
 /// Represents a label selector for filtering workflows based on labels
 #[derive(Debug, Clone, InputObject)]
-/// Represents a label selector for filtering workflows based on labels
 pub struct LabelSelector {
     /// The label key to filter on
     key: String,
@@ -126,19 +126,34 @@ pub struct LabelSelector {
 
 // Workflows--------------------------------------------
 
+/// Represents a workflow parameter filter
+#[derive(Debug, Clone, InputObject)]
+pub struct WorkflowParameterFilter {
+    /// The workflow parameter name
+    key: String,
+
+    /// The workflow parameter value
+    value: String,
+}
+
 /// All the supported Workflows filters
 #[derive(Debug, Default, Clone, InputObject)]
 pub struct WorkflowFilter {
     /// The status of the workflow (e.g., pending, running, succeeded, failed, error)
     workflow_status_filter: Option<WorkflowStatusFilter>,
+
     /// The fedid of the user who created the workflow
     creator: Option<Creator>,
+
     /// The workflow template
     template: Option<Template>,
+
     /// Additional label selectors for filtering workflows
     #[graphql(name = "labelSelectors")]
-    /// Additional label selectors for filtering workflows
     labels: Option<Vec<LabelSelector>>,
+
+    /// Workflow parameter key/value filters
+    parameters: Option<Vec<WorkflowParameterFilter>>,
 }
 
 impl WorkflowFilter {
@@ -149,7 +164,7 @@ impl WorkflowFilter {
             .append_pair("listOptions.labelSelector", labels);
     }
 
-    /// Creates a string of all the reqested filters that belong to the
+    /// Creates a string of all the requested filters that belong to the
     /// `labelSelectors` query key in the Workflow API
     fn create_label_selection(&self) -> String {
         let mut label_selectors = Vec::new();
@@ -162,10 +177,28 @@ impl WorkflowFilter {
         self.template.generate_labels(&mut label_selectors);
 
         self.labels.generate_labels(&mut label_selectors);
+
         label_selectors.join(",")
     }
-}
 
+    /// Returns true when the workflow matches all requested parameters.
+    pub fn matches_parameters(&self, workflow: &IoArgoprojWorkflowV1alpha1Workflow) -> bool {
+        let Some(filters) = &self.parameters else {
+            return true;
+        };
+
+        let Some(arguments) = &workflow.spec.arguments else {
+            return false;
+        };
+
+        filters.iter().all(|filter| {
+            arguments.parameters.iter().any(|parameter| {
+                parameter.name == filter.key
+                    && parameter.value.as_deref() == Some(filter.value.as_str())
+            })
+        })
+    }
+}
 /// Represents workflow status filters
 #[allow(clippy::missing_docs_in_private_items)]
 #[derive(Debug, Default, Clone, InputObject)]
@@ -334,15 +367,192 @@ impl LabelSelector {
 mod tests {
     use crate::graphql::filters::{
         Creator, LabelSelector, ScienceGroup, Template, WorkflowFilter,
-        WorkflowLabelSelectorOperator, WorkflowStatusFilter, WorkflowTemplatesFilter,
+        WorkflowLabelSelectorOperator, WorkflowParameterFilter, WorkflowStatusFilter,
+        WorkflowTemplatesFilter,
+    };
+
+    use argo_workflows_openapi::{
+        IoArgoprojWorkflowV1alpha1Arguments, IoArgoprojWorkflowV1alpha1Parameter,
+        IoArgoprojWorkflowV1alpha1Workflow, IoArgoprojWorkflowV1alpha1WorkflowSpec,
     };
+
+    fn workflow_with_parameters(
+        parameters: Vec<(&str, &str)>,
+    ) -> IoArgoprojWorkflowV1alpha1Workflow {
+        IoArgoprojWorkflowV1alpha1Workflow {
+            api_version: None,
+            kind: None,
+            metadata: Default::default(),
+            spec: IoArgoprojWorkflowV1alpha1WorkflowSpec {
+                arguments: Some(IoArgoprojWorkflowV1alpha1Arguments {
+                    parameters: parameters
+                        .into_iter()
+                        .map(|(name, value)| IoArgoprojWorkflowV1alpha1Parameter {
+                            default: None,
+                            description: None,
+                            enum_: vec![],
+                            global_name: None,
+                            name: name.to_string(),
+                            value: Some(value.to_string()),
+                            value_from: None,
+                        })
+                        .collect(),
+                    ..Default::default()
+                }),
+                ..Default::default()
+            },
+            status: None,
+        }
+    }
+
+    fn parameter_filter(key: &str, value: &str) -> WorkflowParameterFilter {
+        WorkflowParameterFilter {
+            key: key.to_string(),
+            value: value.to_string(),
+        }
+    }
+
+    /// tests ............................
+    ///
+    #[test]
+    fn parameter_filter_matches_workflow_parameter() {
+        let filter = WorkflowFilter {
+            creator: None,
+            template: None,
+            workflow_status_filter: None,
+            labels: None,
+            parameters: Some(vec![parameter_filter("scan_number", "12345")]),
+        };
+
+        let workflow = workflow_with_parameters(vec![("scan_number", "12345")]);
+
+        assert!(filter.matches_parameters(&workflow));
+    }
+
+    /// wrong Value
+    #[test]
+    fn parameter_filter_rejects_wrong_value() {
+        let filter = WorkflowFilter {
+            creator: None,
+            template: None,
+            workflow_status_filter: None,
+            labels: None,
+            parameters: Some(vec![parameter_filter("scan_number", "12345")]),
+        };
+
+        let workflow = workflow_with_parameters(vec![("scan_number", "99999")]);
+
+        assert!(!filter.matches_parameters(&workflow));
+    }
+
+    /// Missing parameter
+    #[test]
+    fn parameter_filter_rejects_missing_parameter() {
+        let filter = WorkflowFilter {
+            creator: None,
+            template: None,
+            workflow_status_filter: None,
+            labels: None,
+            parameters: Some(vec![parameter_filter("scan_number", "12345")]),
+        };
+
+        let workflow = workflow_with_parameters(vec![("beamline", "i14")]);
+
+        assert!(!filter.matches_parameters(&workflow));
+    }
+
+    /// No parameter filter
+    ///
+    #[test]
+    fn no_parameter_filter_matches_any_workflow() {
+        let filter = WorkflowFilter {
+            creator: None,
+            template: None,
+            workflow_status_filter: None,
+            labels: None,
+            parameters: None,
+        };
+
+        let workflow = workflow_with_parameters(vec![("scan_number", "99999")]);
+
+        assert!(filter.matches_parameters(&workflow));
+    }
+
+    /// Multiple parameter filters
+    ///
+    #[test]
+    fn parameter_filters_require_all_parameters_to_match() {
+        let filter = WorkflowFilter {
+            creator: None,
+            template: None,
+            workflow_status_filter: None,
+            labels: None,
+            parameters: Some(vec![
+                parameter_filter("scan_number", "12345"),
+                parameter_filter("beamline", "i14"),
+            ]),
+        };
+
+        let workflow =
+            workflow_with_parameters(vec![("scan_number", "12345"), ("beamline", "i14")]);
+
+        assert!(filter.matches_parameters(&workflow));
+    }
+
+    /// One parameter does not match
+    #[test]
+    fn parameter_filters_reject_when_one_parameter_does_not_match() {
+        let filter = WorkflowFilter {
+            creator: None,
+            template: None,
+            workflow_status_filter: None,
+            labels: None,
+            parameters: Some(vec![
+                parameter_filter("scan_number", "12345"),
+                parameter_filter("beamline", "i14"),
+            ]),
+        };
+
+        let workflow =
+            workflow_with_parameters(vec![("scan_number", "12345"), ("beamline", "i13")]);
+
+        assert!(!filter.matches_parameters(&workflow));
+    }
+
+    /// workflow has no parameters
+    ///
+    #[test]
+    fn parameter_filter_rejects_workflow_without_arguments() {
+        let filter = WorkflowFilter {
+            creator: None,
+            template: None,
+            workflow_status_filter: None,
+            labels: None,
+            parameters: Some(vec![parameter_filter("scan_number", "12345")]),
+        };
+
+        let workflow = IoArgoprojWorkflowV1alpha1Workflow {
+            api_version: None,
+            kind: None,
+            metadata: Default::default(),
+            spec: IoArgoprojWorkflowV1alpha1WorkflowSpec {
+                arguments: None,
+                ..Default::default()
+            },
+            status: None,
+        };
+        assert!(!filter.matches_parameters(&workflow));
+    }
+
     // TEMPLATES--------------------------------------------
+
     #[tokio::test]
     async fn science_group_filter() {
         let science_groups = vec![ScienceGroup::Examples];
         let filters = WorkflowTemplatesFilter {
             science_group: Some(science_groups),
         };
+
         let label_selectors = filters.create_label_selection();
         assert_eq!(
             label_selectors,
@@ -353,6 +563,7 @@ mod tests {
         let filters = WorkflowTemplatesFilter {
             science_group: Some(science_groups),
         };
+
         let label_selectors = filters.create_label_selection();
         assert_eq!(
             label_selectors,
@@ -366,6 +577,7 @@ mod tests {
         let filters = WorkflowTemplatesFilter {
             science_group: Some(science_groups),
         };
+
         let label_selectors = filters.create_label_selection();
 
         let output_groups: Vec<&str> = label_selectors.split(",").collect();
@@ -381,6 +593,7 @@ mod tests {
         let filters = WorkflowTemplatesFilter {
             science_group: Some(science_groups),
         };
+
         let label_selectors = filters.create_label_selection();
         assert_eq!(
             label_selectors,
@@ -399,6 +612,7 @@ mod tests {
                 operator: WorkflowLabelSelectorOperator::Eq,
                 values: Some(vec!["i14".to_string()]),
             }]),
+            parameters: None,
         };
 
         assert_eq!(filters.create_label_selection(), "beamline=i14");
@@ -417,6 +631,7 @@ mod tests {
                 operator: WorkflowLabelSelectorOperator::Eq,
                 values: Some(vec!["i14".to_string()]),
             }]),
+            parameters: None,
         };
 
         assert_eq!(
@@ -436,6 +651,7 @@ mod tests {
                 operator: WorkflowLabelSelectorOperator::Eq,
                 values: Some(vec!["i14".to_string()]),
             }]),
+            parameters: None,
         };
 
         assert_eq!(filters.create_label_selection(), "beamline=i14");
@@ -450,6 +666,7 @@ mod tests {
             template: None,
             workflow_status_filter: None,
             labels: None,
+            parameters: None,
         };
 
         let labels = filters.create_label_selection();
@@ -469,15 +686,20 @@ mod tests {
             succeeded: false,
             running: true,
         };
+
         let filters = WorkflowFilter {
             creator: Some(creator),
             template: None,
             workflow_status_filter: Some(phases),
             labels: None,
+            parameters: None,
         };
 
         let labels = filters.create_label_selection();
-        assert_eq!(labels, "workflows.argoproj.io/phase in (Running),workflows.argoproj.io/creator-preferred-username=test");
+        assert_eq!(
+            labels,
+            "workflows.argoproj.io/phase in (Running),workflows.argoproj.io/creator-preferred-username=test"
+        );
     }
 
     #[tokio::test]
@@ -490,15 +712,20 @@ mod tests {
             succeeded: false,
             running: true,
         };
+
         let filters = WorkflowFilter {
             creator: Some(creator),
             template: None,
             workflow_status_filter: Some(phases),
             labels: None,
+            parameters: None,
         };
 
         let labels = filters.create_label_selection();
-        assert_eq!(labels, "workflows.argoproj.io/phase in (Running, Failed),workflows.argoproj.io/creator-preferred-username=test");
+        assert_eq!(
+            labels,
+            "workflows.argoproj.io/phase in (Running, Failed),workflows.argoproj.io/creator-preferred-username=test"
+        );
     }
 
     #[tokio::test]
@@ -518,9 +745,13 @@ mod tests {
             template: Some(template),
             workflow_status_filter: Some(phases),
             labels: None,
+            parameters: None,
         };
 
         let labels = filters.create_label_selection();
-        assert_eq!(labels, "workflows.argoproj.io/phase in (Running),workflows.argoproj.io/creator-preferred-username=test,workflows.argoproj.io/cluster-workflow-template=template-name");
+        assert_eq!(
+            labels,
+            "workflows.argoproj.io/phase in (Running),workflows.argoproj.io/creator-preferred-username=test,workflows.argoproj.io/cluster-workflow-template=template-name"
+        );
     }
 }
diff --git a/backend/graph-proxy/src/graphql/subscription.rs b/backend/graph-proxy/src/graphql/subscription.rs
index a3dcea797..4956bc3f9 100644
--- a/backend/graph-proxy/src/graphql/subscription.rs
+++ b/backend/graph-proxy/src/graphql/subscription.rs
@@ -12,6 +12,7 @@ use crate::{
         workflows::{Workflow, WorkflowParsingError},
         VisitInput,
     },
+    s3client::{Client as S3Client, S3Bucket},
     validate_token::ValidatedAuthToken,
     ArgoServerUrl,
 };
@@ -46,7 +47,7 @@ struct LogContent {
     pod_name: String,
 }
 
-/// Succees/fail events from Workflows API
+/// Success/fail events from Workflows API
 #[derive(Debug, Deserialize)]
 struct WatchEvent {
     /// Successful event
@@ -58,6 +59,7 @@ struct WatchEvent {
 /// Get authentication token
 pub fn get_auth_token(ctx: &Context<'_>) -> anyhow::Result<String> {
     let auth_token = ctx.data_unchecked::<ValidatedAuthToken>().as_token();
+
     auth_token
         .as_ref()
         .map(|auth| auth.token().to_string())
@@ -66,7 +68,11 @@ pub fn get_auth_token(ctx: &Context<'_>) -> anyhow::Result<String> {
 
 #[Subscription(guard = "AuthGuard")]
 impl WorkflowsSubscription {
-    /// Processing to subscribe to logs for a single pod of a workflow
+    /// Subscribe to logs for a single pod of a workflow.
+    ///
+    /// Logs are streamed live from Argo while the pod is running.
+    /// Once the Argo stream finishes, the archived main.log is retrieved
+    /// from S3 and any lines not already sent are emitted.
     async fn logs(
         &self,
         ctx: &Context<'_>,
@@ -76,10 +82,11 @@ impl WorkflowsSubscription {
     ) -> anyhow::Result<impl Stream<Item = Result<LogEntry, String>>> {
         let auth_token = get_auth_token(ctx)?;
 
-        let namespace = visit.to_string();
         let server_url = ctx.data_unchecked::<ArgoServerUrl>().deref().clone();
         let mut url = server_url;
 
+        let namespace = visit.to_string();
+
         url.path_segments_mut().expect("Invalid base URL").extend([
             "api",
             "v1",
@@ -94,53 +101,199 @@ impl WorkflowsSubscription {
             .append_pair("logOptions.container", "main")
             .append_pair("logOptions.follow", "true");
 
+        tracing::info!(
+            "LOG REQUEST namespace={} workflow={} task={}",
+            namespace,
+            workflow_name,
+            task_id
+        );
+
         let client = reqwest::Client::new();
-        let response = client
+
+        // Try Argo, but don't fail the whole subscription if it errors.
+        let argo_response = client
             .get(url)
             .bearer_auth(auth_token)
             .header("Accept", "text/plain")
             .send()
-            .await?;
+            .await;
+
+        let s3_client = ctx
+            .data::<S3Client>()
+            .map_err(|_| anyhow::anyhow!("Missing S3 client"))?
+            .clone();
+
+        let s3_bucket = ctx
+            .data::<S3Bucket>()
+            .map_err(|_| anyhow::anyhow!("Missing S3 bucket"))?
+            .clone();
+
+        let s3_key = format!("{workflow_name}/{task_id}/main.log");
 
-        let status = response.status();
-        let byte_stream = response.bytes_stream();
         let log_stream = stream! {
-            for await chunk_result in byte_stream {
-                match chunk_result {
-                    Ok(chunk) if status.is_success() => {
-                        let text = String::from_utf8_lossy(&chunk).to_string();
-                        for line in text.lines() {
-                            match serde_json::from_str::<LogResponse>(line) {
-                                Ok(parsed) => {
-                                    if let Some(result) = parsed.result {
-                                        yield Ok(LogEntry {
-                                            content: result.content,
-                                            pod_name: result.pod_name,
-                                        });
-                                    } else {
-                                        yield Err("Missing result in log response".to_string());
+            let mut live_lines = Vec::new();
+
+            // --- Live Argo stream (optional) ---
+            if let Ok(response) = argo_response {
+                let status = response.status();
+                let byte_stream = response.bytes_stream();
+
+                for await chunk_result in byte_stream {
+                    match chunk_result {
+                        Ok(chunk) if status.is_success() => {
+                            let text = String::from_utf8_lossy(&chunk).to_string();
+
+                            for line in text.lines() {
+                                match serde_json::from_str::<LogResponse>(line) {
+                                    Ok(parsed) => {
+                                        if let Some(result) = parsed.result {
+                                            let content = result.content;
+
+                                            let skip_line =
+                                                content.contains("capturing logs")
+                                                || content.contains("waiting for signals")
+                                                || content.contains("sub-process exited")
+                                                || content.contains("file signal handler exiting")
+                                                || content.contains("no need to save artifact")
+                                                || content.contains("no need to save parameter");
+
+                                            if skip_line {
+                                                continue;
+                                            }
+
+                                            live_lines.push(content.clone());
+
+                                            yield Ok(LogEntry {
+                                                content,
+                                                pod_name: result.pod_name,
+                                            });
+                                        } else {
+                                            yield Err(
+                                                "Missing result in log response".to_string()
+                                            );
+                                        }
+                                    }
+
+                                    Err(_) => {
+                                        let content = line.trim().to_string();
+
+                                        if content.starts_with("{\"result\"") {
+                                            continue;
+                                        }
+
+                                        if !content.is_empty() {
+                                            live_lines.push(content.clone());
+
+                                            yield Ok(LogEntry {
+                                                content,
+                                                pod_name: task_id.clone(),
+                                            });
+                                        }
                                     }
-                                }
-                                Err(_) => {
-                                    yield Ok(LogEntry {
-                                        content: line.trim().to_string(),
-                                        pod_name: task_id.clone(),
-                                    });
                                 }
                             }
                         }
+
+                        Ok(_) => {
+                            // Argo failed (e.g. 404), log and continue to S3.
+                            tracing::warn!(
+                                "Argo log request failed with status {status}, will try S3 fallback"
+                            );
+                        }
+
+                        Err(err) => {
+                            tracing::warn!(
+                                "Failed to read log chunk from Argo: {err}, will try S3 fallback"
+                            );
+                        }
                     }
-                    Ok(_) | Err(_) => {
-                        yield Err("Failed to read log chunk".to_string());
+                }
+            } else {
+                tracing::warn!("Argo log request failed entirely, will try S3 fallback");
+            }
+
+            // --- S3 fallback (always attempted) ---
+            tracing::info!("ARCHIVE_LOOKUP: {}", s3_key);
+
+            let archive_response = match s3_client
+                .get_object()
+                .bucket(s3_bucket)
+                .key(&s3_key)
+                .send()
+                .await
+            {
+                Ok(response) => response,
+
+                Err(err) => {
+                    yield Err(format!(
+                        "Failed to retrieve archived log artifact: {err:?}"
+                    ));
+                    return;
+                }
+            };
+
+            let archive_bytes = match archive_response.body.collect().await {
+                Ok(bytes) => bytes,
+
+                Err(err) => {
+                    yield Err(format!(
+                        "Failed to read archived log artifact: {err}"
+                    ));
+                    return;
+                }
+            };
+
+            let archived_text =
+                String::from_utf8_lossy(archive_bytes.into_bytes().as_ref()).to_string();
+
+            let archived_lines: Vec<String> = archived_text
+                .lines()
+                .map(str::to_string)
+                .collect();
+
+            // Determine where the archived log begins beyond what was already
+            // sent by the live Argo stream.
+            let mut archive_start = 0;
+
+            while archive_start < live_lines.len()
+                && archive_start < archived_lines.len()
+                && live_lines[archive_start] == archived_lines[archive_start]
+            {
+                archive_start += 1;
+            }
+
+            // If the archive and live stream don't share the same prefix,
+            // try to locate the final live line in the archive.
+            if archive_start < live_lines.len() {
+                if let Some(last_live_line) = live_lines.last() {
+                    if let Some(position) = archived_lines
+                        .iter()
+                        .rposition(|line| line == last_live_line)
+                    {
+                        archive_start = position + 1;
+                    } else {
+                        yield Err(
+                            "Unable to reconcile live and archived logs".to_string()
+                        );
+                        return;
                     }
                 }
             }
+
+            // Send only the archived lines that were not already emitted
+            // from the live Argo stream.
+            for line in archived_lines.into_iter().skip(archive_start) {
+                yield Ok(LogEntry {
+                    content: line,
+                    pod_name: task_id.clone(),
+                });
+            }
         };
 
         Ok(log_stream)
     }
 
-    /// Processing to subscribe to data for all workflows in a session
+    /// Subscribe to data for all workflows in a session.
     async fn workflow(
         &self,
         ctx: &Context<'_>,
@@ -166,6 +319,7 @@ impl WorkflowsSubscription {
         );
 
         let client = reqwest::Client::new();
+
         let response = client
             .get(url)
             .bearer_auth(auth_token)
@@ -177,6 +331,7 @@ impl WorkflowsSubscription {
 
         let stream = response.then(move |event_result| {
             let session_clone = visit.clone();
+
             async move {
                 match event_result {
                     Ok(event) => {
@@ -191,14 +346,18 @@ impl WorkflowsSubscription {
                                     Err("No workflow object returned".to_string())
                                 }
                             }
+
                             (None, Some(err)) => Err(err.message),
+
                             (None, None) => Err("Missing result and error in event".to_string()),
+
                             (Some(_), Some(_)) => {
                                 Err("Conflicting result and error in event".to_string())
                             }
                         }
                     }
-                    Err(_err) => Err("Failed to read event from stream".to_string()),
+
+                    Err(_) => Err("Failed to read event from stream".to_string()),
                 }
             }
         });
@@ -216,7 +375,6 @@ struct StreamError {
 
 #[cfg(test)]
 mod tests {
-
     use std::{env, fs, path::PathBuf};
 
     use async_graphql::Request;
@@ -227,20 +385,157 @@ mod tests {
     use serde_json::{json, Value};
     use url::Url;
 
-    use crate::graphql::Visit;
-    use crate::ArgoServerUrl;
-
     use crate::graphql::root_schema_builder;
+    use crate::graphql::Visit;
     use crate::validate_token::ValidatedAuthToken;
+    use crate::{ArgoServerUrl, Client, S3Bucket, S3ClientArgs};
 
     fn test_token() -> ValidatedAuthToken {
         let token = Authorization::bearer("test-token").expect("token always valid");
+
         ValidatedAuthToken::Valid(token)
     }
 
+    #[tokio::test]
+    async fn logs_subscription_reads_archived_s3_log_after_live_stream() {
+        let workflow_name = "numpy-benchmark-wdkwj";
+        let task_id = "numpy-benchmark-wdkwj";
+
+        let visit = Visit {
+            proposal_code: "mg".to_string(),
+            proposal_number: 36964,
+            number: 1,
+        };
+
+        let mut server = mockito::Server::new_async().await;
+
+        // Mock the live Argo log endpoint.
+        let argo_log_body = concat!(
+            r#"{"result":{"content":"line 1","podName":"numpy-benchmark-wdkwj"}}"#,
+            "\n",
+            r#"{"result":{"content":"line 2","podName":"numpy-benchmark-wdkwj"}}"#,
+            "\n",
+        );
+
+        let argo_log_path = format!("/api/v1/workflows/{visit}/{workflow_name}/log");
+
+        let argo_log_endpoint = server
+            .mock("GET", argo_log_path.as_str())
+            .match_query(Matcher::UrlEncoded("podName".into(), task_id.into()))
+            .match_query(Matcher::UrlEncoded(
+                "logOptions.container".into(),
+                "main".into(),
+            ))
+            .match_query(Matcher::UrlEncoded(
+                "logOptions.follow".into(),
+                "true".into(),
+            ))
+            .with_status(200)
+            .with_header("content-type", "text/plain")
+            .with_body(argo_log_body)
+            .create_async()
+            .await;
+
+        // Mock the archived S3 main.log.
+        //
+        // Path-style S3 addressing produces:
+        //
+        // /test-bucket/numpy-benchmark-wdkwj/numpy-benchmark-wdkwj/main.log
+        let _s3_key = format!("{workflow_name}/{task_id}/main.log");
+        // let s3_path = format!("/test-bucket/{s3_key}");
+
+        let s3_log_endpoint = server
+            .mock("GET", mockito::Matcher::Any)
+            .with_status(200)
+            .with_header("content-type", "text/plain")
+            .with_body("line 1\nline 2\nline 3\nline 4\n")
+            .create_async()
+            .await;
+
+        let s3_bucket = S3Bucket("test-bucket".to_string());
+
+        let s3_client_args = S3ClientArgs {
+            s3_endpoint_url: Some(Url::parse(&server.url()).unwrap()),
+            s3_access_key_id: Some("test-access-key".to_string()),
+            s3_secret_access_key: Some("test-secret-key".to_string()),
+            s3_force_path_style: true,
+            s3_region: Some("us-west-2".to_string()),
+        };
+
+        let s3_client = Client::from(s3_client_args);
+
+        let argo_server_url = Url::parse(&server.url()).unwrap();
+
+        let schema = root_schema_builder()
+            .data(ArgoServerUrl(argo_server_url))
+            .data(test_token())
+            .data(s3_client)
+            .data(s3_bucket)
+            .finish();
+
+        let request = Request::new(format!(
+            r#"
+            subscription {{
+                logs(
+                    visit: {{
+                        proposalCode: "{}",
+                        proposalNumber: {},
+                        number: {}
+                    }}
+                    workflowName: "{}"
+                    taskId: "{}"
+                ) {{
+                    content
+                    podName
+                }}
+            }}
+            "#,
+            visit.proposal_code, visit.proposal_number, visit.number, workflow_name, task_id,
+        ));
+
+        let mut response_stream = schema.execute_stream(request);
+
+        let mut logs = Vec::new();
+
+        while let Some(response) = response_stream.next().await {
+            assert!(
+                response.errors.is_empty(),
+                "unexpected GraphQL errors: {:?}",
+                response.errors
+            );
+
+            let data = response.data.into_json().expect("invalid response JSON");
+
+            if let Some(log) = data.get("logs").and_then(|value| value.as_object()) {
+                logs.push((
+                    log["content"].as_str().unwrap().to_string(),
+                    log["podName"].as_str().unwrap().to_string(),
+                ));
+            }
+
+            if logs.len() == 4 {
+                break;
+            }
+        }
+
+        assert_eq!(
+            logs,
+            vec![
+                ("line 1".to_string(), task_id.to_string()),
+                ("line 2".to_string(), task_id.to_string()),
+                ("line 3".to_string(), task_id.to_string()),
+                ("line 4".to_string(), task_id.to_string()),
+            ]
+        );
+
+        argo_log_endpoint.assert_async().await;
+        s3_log_endpoint.assert_async().await;
+    }
+
     #[tokio::test]
     async fn single_workflow_subscription_returns_first_event() {
         let workflow_name = "numpy-benchmark-wdkwj";
+
         let visit = Visit {
             proposal_code: "mg".to_string(),
             proposal_number: 36964,
@@ -248,6 +543,7 @@ mod tests {
         };
 
         let mut workflow_file_path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+
         workflow_file_path.push("test-assets");
         workflow_file_path.push("get-workflow-wdkwj.json");
 
@@ -270,7 +566,9 @@ mod tests {
         );
 
         let mut server = mockito::Server::new_async().await;
+
         let path = format!("/api/v1/workflow-events/{visit}");
+
         let workflow_events_endpoint = server
             .mock("GET", path.as_str())
             .match_query(Matcher::UrlEncoded(
@@ -292,15 +590,19 @@ mod tests {
 
         let request = Request::new(format!(
             r#"
-        subscription {{
-            workflow(
-                name: "{}",
-                visit: {{ proposalCode: "{}", proposalNumber: {}, number: {} }}
-            ) {{
-                name
+            subscription {{
+                workflow(
+                    name: "{}",
+                    visit: {{
+                        proposalCode: "{}",
+                        proposalNumber: {},
+                        number: {}
+                    }}
+                ) {{
+                    name
+                }}
             }}
-        }}
-        "#,
+            "#,
             workflow_name, visit.proposal_code, visit.proposal_number, visit.number
         ));
 
@@ -346,15 +648,19 @@ mod tests {
 
         let request = Request::new(
             r#"
-        subscription {
-            workflow(
-                name: "workflowName",
-                visit: { proposalCode: "xy", proposalNumber: 1234, number: 5678 }
-            ) {
-                name
+            subscription {
+                workflow(
+                    name: "workflowName",
+                    visit: {
+                        proposalCode: "xy",
+                        proposalNumber: 1234,
+                        number: 5678
+                    }
+                ) {
+                    name
+                }
             }
-        }
-    "#,
+            "#,
         );
 
         let mut response_stream = schema.execute_stream(request);
@@ -365,6 +671,7 @@ mod tests {
             .expect("subscription stream ended before first response");
 
         let expected_data = json!(null);
+
         assert_eq!(
             first_response
                 .data
@@ -384,6 +691,7 @@ mod tests {
             .expect("invalid json");
 
         let expected_value = json!(AuthErrorCode::Unauthenticated.to_string());
+
         assert_eq!(error_code, expected_value);
     }
 }
diff --git a/backend/graph-proxy/src/graphql/workflows.rs b/backend/graph-proxy/src/graphql/workflows.rs
index e40240d8f..32b37a1f6 100644
--- a/backend/graph-proxy/src/graphql/workflows.rs
+++ b/backend/graph-proxy/src/graphql/workflows.rs
@@ -373,16 +373,17 @@ impl Artifact<'_> {
             .expires_in(std::time::Duration::from_secs(3600))
             .build()
             .unwrap();
-        s3_client
+        let req = s3_client
             .get_object()
             .bucket(s3_bucket.clone())
             .key(key)
             .presigned(presigning_config)
             .await
-            .map_err(|_| WorkflowParsingError::InvalidPresignedS3Url)
-            .and_then(|req| {
-                Url::parse(req.uri()).map_err(|_| WorkflowParsingError::InvalidPresignedS3Url)
-            })
+            .map_err(|_| WorkflowParsingError::InvalidPresignedS3Url)?;
+
+        tracing::info!("PRESIGNED URL: {}", req.uri());
+
+        Url::parse(req.uri()).map_err(|_| WorkflowParsingError::InvalidPresignedS3Url)
     }
 
     /// The MIME type of the artifact data
@@ -650,11 +651,17 @@ impl WorkflowsQuery {
             }
         };
 
-        let workflows = workflows_response
-            .items
+        let mut workflow_items = workflows_response.items;
+
+        if let Some(filter) = &filter {
+            workflow_items.retain(|workflow| filter.matches_parameters(workflow));
+        }
+
+        let workflows = workflow_items
             .into_iter()
             .map(|workflow| Workflow::new(workflow, visit.clone().into()))
             .collect::<Vec<_>>();
+
         let mut connection = Connection::new(
             cursor_index > 0,
             workflows_response.metadata.continue_.is_some(),
diff --git a/frontend/.devcontainer/devcontainer-lock.json b/frontend/.devcontainer/devcontainer-lock.json
new file mode 100644
index 000000000..f1bff2f3e
--- /dev/null
+++ b/frontend/.devcontainer/devcontainer-lock.json
@@ -0,0 +1,14 @@
+{
+  "features": {
+    "ghcr.io/devcontainers/features/common-utils:2.4.2": {
+      "version": "2.4.2",
+      "resolved": "ghcr.io/devcontainers/features/common-utils@sha256:bebfdcd6097a35506bf0f064a31e52ad4205467d9d7a226a688f51b851c88b65",
+      "integrity": "sha256:bebfdcd6097a35506bf0f064a31e52ad4205467d9d7a226a688f51b851c88b65"
+    },
+    "ghcr.io/devcontainers/features/git-lfs:1.2.3": {
+      "version": "1.2.3",
+      "resolved": "ghcr.io/devcontainers/features/git-lfs@sha256:7acbf0a99325949b6a2906ebf5aa421dad72b89ab8045031a60e69cb394a16b1",
+      "integrity": "sha256:7acbf0a99325949b6a2906ebf5aa421dad72b89ab8045031a60e69cb394a16b1"
+    }
+  }
+}
diff --git a/frontend/dashboard/src/routes/SingleWorkflowPage.tsx b/frontend/dashboard/src/routes/SingleWorkflowPage.tsx
index 9a0fa0f36..e38056187 100644
--- a/frontend/dashboard/src/routes/SingleWorkflowPage.tsx
+++ b/frontend/dashboard/src/routes/SingleWorkflowPage.tsx
@@ -3,11 +3,12 @@ import { useParams, Link, useSearchParams } from "react-router-dom";
 import { Suspense, useMemo } from "react";
 import "react-resizable/css/styles.css";
 import { Breadcrumbs } from "@diamondlightsource/sci-react-ui";
-import { SingleWorkflowView, WorkflowsNavbar } from "relay-workflows-lib";
+
 import {
   visitTextToVisit,
   WorkflowErrorBoundaryWithRetry,
 } from "workflows-lib";
+import { SingleWorkflowView, WorkflowsNavbar } from "relay-workflows-lib";
 
 function SingleWorkflowPage() {
   const { visitid, workflowName } = useParams<{
@@ -65,6 +66,13 @@ function SingleWorkflowPage() {
                     workflowName={workflowName}
                     taskIds={taskIds}
                   />
+
+                  {/* Real-time Task Log Viewer */}
+                  {/* <TaskLogViewer
+                    visit={visit}
+                    workflowName={workflowName}
+                    selectedTaskId={selectedTaskId}
+                  /> */}
                 </Suspense>
               )}
             </WorkflowErrorBoundaryWithRetry>
@@ -79,7 +87,6 @@ function SingleWorkflowPage() {
           mb={4}
         >
           <Typography>No valid workflow selected</Typography>
-          {/* Go to instrumentSession or home page */}
         </Box>
       )}
     </>
diff --git a/frontend/relay-workflows-lib/lib/components/BaseWorkflowRelay.tsx b/frontend/relay-workflows-lib/lib/components/BaseWorkflowRelay.tsx
index fb92e1a42..67f9a1dfa 100644
--- a/frontend/relay-workflows-lib/lib/components/BaseWorkflowRelay.tsx
+++ b/frontend/relay-workflows-lib/lib/components/BaseWorkflowRelay.tsx
@@ -35,6 +35,7 @@ interface BaseWorkflowRelayProps {
   expanded?: boolean;
   onChange?: () => void;
   fragmentRef: BaseWorkflowRelayFragment$key;
+  onSelectTask?: (taskId: string) => void;
 }
 
 export default function BaseWorkflowRelay({
@@ -43,36 +44,30 @@ export default function BaseWorkflowRelay({
   expanded,
   onChange,
   fragmentRef,
+  onSelectTask,
 }: BaseWorkflowRelayProps) {
   const { workflowName: workflowNameURL } = useParams<{
     workflowName: string;
   }>();
+
   const navigate = useNavigate();
+
   const data = useFragment(BaseWorkflowRelayFragment, fragmentRef);
-  const statusText = data.status?.__typename ?? "Unknown";
-  const [selectedTaskIds, setSelectedTaskIds] = useSelectedTaskIds();
 
-  const onNavigate = React.useCallback(
-    (taskId: string, event?: React.MouseEvent) => {
-      const isCtrl = event?.ctrlKey || event?.metaKey;
+  const statusText = data.status?.__typename ?? "Unknown";
 
-      let updatedTaskIds: string[];
+  const [selectedTaskIds] = useSelectedTaskIds();
 
-      if (isCtrl) {
-        updatedTaskIds = selectedTaskIds.includes(taskId)
-          ? selectedTaskIds.filter((id) => id !== taskId)
-          : [...selectedTaskIds, taskId];
-      } else {
-        updatedTaskIds = [taskId];
-      }
+  const onNavigate = React.useCallback(
+    (taskId: string) => {
       if (workflowNameURL !== data.name) {
         void navigate(`/workflows/${visitToText(data.visit)}/${data.name}`);
       }
-      setSelectedTaskIds(updatedTaskIds);
+
+      onSelectTask?.(taskId);
     },
-    [navigate, selectedTaskIds, setSelectedTaskIds, workflowNameURL, data],
+    [navigate, workflowNameURL, data, onSelectTask],
   );
-
   return (
     <Box
       sx={{
diff --git a/frontend/relay-workflows-lib/lib/components/RelayEnvironment.ts b/frontend/relay-workflows-lib/lib/components/RelayEnvironment.ts
index 40bbeaf47..ad550301d 100644
--- a/frontend/relay-workflows-lib/lib/components/RelayEnvironment.ts
+++ b/frontend/relay-workflows-lib/lib/components/RelayEnvironment.ts
@@ -34,7 +34,8 @@ function ensureKeycloakInit(): Promise<boolean> {
         scope: KEYCLOAK_SCOPE,
       })
       .catch((err: unknown) => {
-        console.error("Keycloak init failed", err);
+        const error = err instanceof Error ? err : new Error(String(err));
+        console.error("Keycloak init failed", error);
         return false;
       });
   }
@@ -43,18 +44,16 @@ function ensureKeycloakInit(): Promise<boolean> {
 
 if (!USE_AUTH_GATEWAY) {
   keycloak.onTokenExpired = () => {
-    console.log("JWT expired");
     keycloak
       .updateToken(10)
       .then((refreshed) => {
-        if (refreshed) {
-          console.log("Fetched new JWT");
-        } else {
+        if (!refreshed) {
           console.warn("Token still valid");
         }
       })
       .catch((err: unknown) => {
-        console.error("Failed to update JWT", err);
+        const error = err instanceof Error ? err : new Error(String(err));
+        console.error("Failed to update JWT", error);
       });
   };
 }
@@ -77,7 +76,7 @@ const fetchFn: FetchFunction = async (request, variables) => {
   const resp = await fetch(HTTP_ENDPOINT, {
     method: "POST",
     headers,
-    credentials: "include",
+    //  credentials: "include",
     body: JSON.stringify({
       query: request.text, // <-- The GraphQL document composed by Relay
       variables,
@@ -94,6 +93,27 @@ const fetchFn: FetchFunction = async (request, variables) => {
 
 export const wsClient = createClient({
   url: WS_ENDPOINT,
+  on: {
+    connecting: () => {
+      console.log("WS connecting");
+    },
+    opened: () => {
+      console.log("WS opened");
+    },
+    connected: () => {
+      console.log("WS connected");
+    },
+    closed: (event) => {
+      console.log("WS closed", event);
+    },
+  },
+  webSocketImpl: class extends WebSocket {
+    constructor(url: string | URL, protocols?: string | string[]) {
+      console.log("Creating browser WebSocket:", url);
+      super(url, protocols);
+    }
+  },
+
   connectionParams: async () => {
     if (!USE_AUTH_GATEWAY && !keycloak.authenticated) {
       await ensureKeycloakInit();
@@ -117,20 +137,25 @@ const subscribeFn: SubscribeFunction = (operation, variables) => {
       },
       {
         next: (response) => {
-          const data = response.data;
-          if (data) {
-            sink.next({ data } as GraphQLResponse);
-          } else if (data == null) {
-            console.warn("Data is null:", response);
-          } else {
-            console.error("Subscription error response:", response);
-            sink.error(new Error("Subscription response missing data"));
-          }
+          sink.next(response as GraphQLResponse);
+        },
+
+        error: (error) => {
+          sink.error(
+            error instanceof Error
+              ? error
+              : new Error(
+                  typeof error === "string" ? error : JSON.stringify(error),
+                ),
+          );
+        },
+
+        complete: () => {
+          sink.complete();
         },
-        error: sink.error.bind(sink),
-        complete: sink.complete.bind(sink),
       },
     );
+
     return cleanup;
   });
 };
@@ -156,8 +181,8 @@ export async function getUser(): Promise<AuthState | null> {
     let parsedToken: JSONObject = {};
     try {
       parsedToken = parseJwt(keycloak.token);
-    } catch (error) {
-      console.error("Could not parse JWT: ", error);
+    } catch {
+      console.warn("Unable to parse Keycloak token.");
     }
     const user: AuthState = {
       name: parsedToken.name as string,
diff --git a/frontend/relay-workflows-lib/lib/components/TasksFlow.tsx b/frontend/relay-workflows-lib/lib/components/TasksFlow.tsx
index d83256560..2bb0d623b 100644
--- a/frontend/relay-workflows-lib/lib/components/TasksFlow.tsx
+++ b/frontend/relay-workflows-lib/lib/components/TasksFlow.tsx
@@ -146,28 +146,36 @@ const TasksFlow: React.FC<TasksFlowProps> = ({
     const handleResizeAndOverflow = () => {
       if (containerRef.current) {
         const { width, height } = containerRef.current.getBoundingClientRect();
-        const boundingBox = getNodesBounds(layoutedNodes);
+
+        const nodeLookup = nodesWithHighlights ?? [];
+
+        const boundingBox = getNodesBounds(nodeLookup);
+
         setIsOverflow(boundingBox.width > width || boundingBox.height > height);
       }
     };
+
     const resizeObserver = new ResizeObserver(handleResizeAndOverflow);
+
     const currentContainerRef = containerRef.current;
 
     if (currentContainerRef) {
       resizeObserver.observe(currentContainerRef);
     }
+
     handleResizeAndOverflow();
+
     window.addEventListener("resize", handleResizeAndOverflow);
 
     return () => {
       if (currentContainerRef) {
         resizeObserver.unobserve(currentContainerRef);
       }
+
       resizeObserver.disconnect();
       window.removeEventListener("resize", handleResizeAndOverflow);
     };
-  }, [layoutedNodes, layoutedEdges]);
-
+  }, [nodesWithHighlights]);
   return (
     <Box ref={containerRef} display="flex" height="100%" width="100%">
       <Box
diff --git a/frontend/relay-workflows-lib/lib/main.ts b/frontend/relay-workflows-lib/lib/main.ts
index 9f839ecfd..9a00d7fc5 100644
--- a/frontend/relay-workflows-lib/lib/main.ts
+++ b/frontend/relay-workflows-lib/lib/main.ts
@@ -1,4 +1,5 @@
 export { default as Workflow } from "./components/WorkflowRelay";
+export * from "./views/TaskLogViewer";
 export { default as Submission } from "./components/SubmissionForm";
 export { default as RetriggerWorkflow } from "./query-components/RetriggerWorkflow";
 export { default as SubmittedMessagesList } from "./components/SubmittedMessagesList";
diff --git a/frontend/relay-workflows-lib/lib/views/BaseSingleWorkflowView.tsx b/frontend/relay-workflows-lib/lib/views/BaseSingleWorkflowView.tsx
index b3cdb6bbd..8f0363dca 100644
--- a/frontend/relay-workflows-lib/lib/views/BaseSingleWorkflowView.tsx
+++ b/frontend/relay-workflows-lib/lib/views/BaseSingleWorkflowView.tsx
@@ -1,12 +1,6 @@
 import { useCallback, useEffect, useMemo, useState } from "react";
 import { Box, ToggleButton } from "@mui/material";
-import {
-  Artifact,
-  Task,
-  TaskNode,
-  TaskInfo,
-  buildTaskTree,
-} from "workflows-lib";
+import { Artifact, Task, TaskInfo, buildTaskTree } from "workflows-lib";
 import {
   useFetchedTasks,
   useSelectedTaskIds,
@@ -15,9 +9,16 @@ import WorkflowInfo from "../components/WorkflowInfo";
 import { graphql, useFragment } from "react-relay";
 import { BaseSingleWorkflowViewFragment$key } from "./__generated__/BaseSingleWorkflowViewFragment.graphql";
 import BaseWorkflowRelay from "../components/BaseWorkflowRelay";
+import { TaskLogViewer } from "./TaskLogViewer";
 
 export const BaseSingleWorkflowViewFragment = graphql`
   fragment BaseSingleWorkflowViewFragment on Workflow @relay(mask: false) {
+    name
+    visit {
+      proposalCode
+      proposalNumber
+      number
+    }
     status {
       __typename
     }
@@ -31,36 +32,66 @@ export const BaseSingleWorkflowViewFragment = graphql`
 interface BaseSingleWorkflowViewProps {
   fragmentRef: BaseSingleWorkflowViewFragment$key | null;
   taskIds?: string[];
+  onSelectTask?: (taskId: string) => void;
 }
 
 export default function BaseSingleWorkflowView({
   taskIds,
   fragmentRef,
+  onSelectTask,
 }: BaseSingleWorkflowViewProps) {
   const data = useFragment(BaseSingleWorkflowViewFragment, fragmentRef);
+
   const fetchedTasks = useFetchedTasks(data ?? null);
-  const [selectedTaskIds, setSelectedTaskIds] = useSelectedTaskIds();
+
+  // Task selected for log viewer
+  const [selectedTaskId, setSelectedTaskId] = useState<string | null>(null);
+
   const [filledTaskId, setFilledTaskId] = useState<string | null>(null);
 
+  // Resolve task name from id
+  const selectedTask = useMemo(
+    () => fetchedTasks.find((task) => task.id === selectedTaskId),
+    [fetchedTasks, selectedTaskId],
+  );
+
+  const [selectedTaskIds, setSelectedTaskIds] = useSelectedTaskIds();
+
+  // // Artifact hover highlight
+  // const [
+  //   filledTaskId,
+  //   setFilledTaskId,
+  // ] = useState<string | null>(null);
+
   const taskTree = useMemo(() => buildTaskTree(fetchedTasks), [fetchedTasks]);
 
-  const outputTaskIds: string[] = useMemo(() => {
+  type TaskTreeNode = {
+    id: string;
+    children?: TaskTreeNode[];
+  };
+
+  const outputTaskIds = useMemo(() => {
     const newOutputTaskIds: string[] = [];
-    const traverse = (tasks: TaskNode[]) => {
+
+    const traverse = (tasks: TaskTreeNode[]): void => {
       const sortedTasks = [...tasks].sort((a, b) => a.id.localeCompare(b.id));
+
       sortedTasks.forEach((taskNode) => {
-        if (
-          taskNode.children &&
-          taskNode.children.length === 0 &&
-          !newOutputTaskIds.includes(taskNode.id)
-        ) {
-          newOutputTaskIds.push(taskNode.id);
-        } else if (taskNode.children && taskNode.children.length > 0) {
-          traverse(taskNode.children);
+        const children = taskNode.children ?? [];
+
+        if (children.length === 0) {
+          if (!newOutputTaskIds.includes(taskNode.id)) {
+            newOutputTaskIds.push(taskNode.id);
+          }
+          return;
         }
+
+        traverse(children);
       });
     };
-    traverse(taskTree);
+
+    traverse(taskTree as TaskTreeNode[]);
+
     return newOutputTaskIds;
   }, [taskTree]);
 
@@ -70,14 +101,12 @@ export default function BaseSingleWorkflowView({
 
   const handleSelectClear = () => {
     setSelectedTaskIds([]);
+    setSelectedTaskId(null);
   };
 
-  const onArtifactHover = useCallback(
-    (artifact: Artifact | null) => {
-      setFilledTaskId(artifact ? artifact.parentTaskId : null);
-    },
-    [setFilledTaskId],
-  );
+  const onArtifactHover = useCallback((artifact: Artifact | null) => {
+    setFilledTaskId(artifact ? artifact.parentTaskId : null);
+  }, []);
 
   useEffect(() => {
     setSelectedTaskIds(taskIds ?? []);
@@ -89,6 +118,7 @@ export default function BaseSingleWorkflowView({
           .map((id) => fetchedTasks.find((task) => task.id === id))
           .filter((task): task is Task => !!task)
       : fetchedTasks;
+
     return filteredTasks.flatMap((task) => task.artifacts);
   }, [selectedTaskIds, fetchedTasks]);
 
@@ -120,7 +150,10 @@ export default function BaseSingleWorkflowView({
             display="flex"
             flexDirection="column"
             gap={1}
-            sx={{ position: "absolute", left: "-100px" }}
+            sx={{
+              position: "absolute",
+              left: "-100px",
+            }}
           >
             <ToggleButton
               value="output"
@@ -129,32 +162,47 @@ export default function BaseSingleWorkflowView({
             >
               OUTPUT
             </ToggleButton>
+
             <ToggleButton
-              value="output"
-              aria-label="output"
+              value="clear"
+              aria-label="clear"
               onClick={handleSelectClear}
             >
               CLEAR
             </ToggleButton>
           </Box>
 
-          {fragmentRef && (
-            <BaseWorkflowRelay
-              fragmentRef={data}
-              workflowLink
-              filledTaskId={filledTaskId}
-              expanded={true}
-            />
-          )}
+          <BaseWorkflowRelay
+            fragmentRef={data}
+            workflowLink
+            filledTaskId={filledTaskId}
+            expanded={true}
+            onSelectTask={(taskId) => {
+              console.log("BASE SINGLE TASK SELECTED:", taskId);
+
+              setSelectedTaskId(taskId);
+
+              onSelectTask?.(taskId);
+            }}
+          />
         </Box>
       </Box>
+
+      <TaskLogViewer
+        visit={data.visit}
+        workflowName={data.name}
+        selectedTaskId={selectedTaskId}
+        selectedTaskName={selectedTask?.name}
+      />
+
       {taskIds && (
         <TaskInfo
           artifactList={artifactList}
           onArtifactHover={onArtifactHover}
         />
       )}
-      {<WorkflowInfo fragmentRef={data} />}
+
+      <WorkflowInfo fragmentRef={data} />
     </>
   );
 }
diff --git a/frontend/relay-workflows-lib/lib/views/SingleWorkflowView.tsx b/frontend/relay-workflows-lib/lib/views/SingleWorkflowView.tsx
index 3aed782dc..1527cb31c 100644
--- a/frontend/relay-workflows-lib/lib/views/SingleWorkflowView.tsx
+++ b/frontend/relay-workflows-lib/lib/views/SingleWorkflowView.tsx
@@ -23,6 +23,7 @@ export interface SingleWorkflowViewProps {
   workflowName: string;
   taskIds?: string[];
   onNullSubscriptionData?: () => void;
+  onSelectTask?: (taskId: string) => void;
 }
 
 export default function SingleWorkflowView(props: SingleWorkflowViewProps) {
@@ -45,6 +46,7 @@ export default function SingleWorkflowView(props: SingleWorkflowViewProps) {
     <BaseSingleWorkflowView
       fragmentRef={queryData.workflow ?? null}
       taskIds={props.taskIds}
+      onSelectTask={props.onSelectTask}
     />
   ) : (
     <LiveSingleWorkflowView
diff --git a/frontend/relay-workflows-lib/lib/views/TaskLogViewer.tsx b/frontend/relay-workflows-lib/lib/views/TaskLogViewer.tsx
new file mode 100644
index 000000000..920209dd9
--- /dev/null
+++ b/frontend/relay-workflows-lib/lib/views/TaskLogViewer.tsx
@@ -0,0 +1,250 @@
+import React, { useEffect, useMemo, useRef, useState } from "react";
+import {
+  Accordion,
+  AccordionSummary,
+  AccordionDetails,
+  Box,
+  Typography,
+  CircularProgress,
+} from "@mui/material";
+import ArrowDropDownIcon from "@mui/icons-material/ArrowDropDown";
+import { graphql, useSubscription } from "react-relay";
+import { GraphQLSubscriptionConfig } from "relay-runtime";
+import { Visit } from "@diamondlightsource/sci-react-ui";
+import { TaskLogViewerSubscription } from "./__generated__/TaskLogViewerSubscription.graphql";
+
+const taskLogViewerSubscription = graphql`
+  subscription TaskLogViewerSubscription(
+    $visit: VisitInput!
+    $workflowName: String!
+    $taskId: String!
+  ) {
+    logs(visit: $visit, workflowName: $workflowName, taskId: $taskId) {
+      content
+      podName
+    }
+  }
+`;
+
+interface TaskLogViewerProps {
+  visit: Visit;
+  workflowName: string;
+  selectedTaskId: string | null;
+  selectedTaskName?: string;
+}
+
+interface TaskLogViewerContentProps {
+  visit: Visit;
+  workflowName: string;
+  selectedTaskId: string;
+  selectedTaskName?: string;
+}
+
+function TaskLogViewerContent({
+  visit,
+  workflowName,
+  selectedTaskId,
+  selectedTaskName,
+}: TaskLogViewerContentProps) {
+  const [logLines, setLogLines] = useState<string[]>([]);
+  const [taskCompleted, setTaskCompleted] = useState(false);
+  const [expanded, setExpanded] = useState(true);
+  const containerRef = useRef<HTMLDivElement>(null);
+
+  const subscriptionConfig = useMemo<
+    GraphQLSubscriptionConfig<TaskLogViewerSubscription>
+  >(
+    () => ({
+      subscription: taskLogViewerSubscription,
+      variables: {
+        visit,
+        workflowName,
+        taskId: selectedTaskId,
+      },
+
+      onNext: (payload) => {
+        if (!payload) {
+          return;
+        }
+        const line = payload.logs.content;
+
+        if (!line) {
+          return;
+        }
+
+        setLogLines((previousLines) => [...previousLines, line]);
+
+        const hasFinished =
+          line.includes("sub-process exited") ||
+          line.includes("completed") ||
+          line.includes("finished") ||
+          line.includes("Image saved") ||
+          line.includes("saved image") ||
+          line.includes("done");
+
+        if (hasFinished) {
+          setTaskCompleted(true);
+        }
+      },
+
+      onCompleted: () => {
+        setTaskCompleted(true);
+      },
+
+      onError: (error) => {
+        console.error("Log subscription error:", error);
+        setTaskCompleted(true);
+      },
+    }),
+    [visit, workflowName, selectedTaskId],
+  );
+
+  useSubscription(subscriptionConfig);
+
+  useEffect(() => {
+    if (containerRef.current) {
+      containerRef.current.scrollTop = containerRef.current.scrollHeight;
+    }
+  }, [logLines]);
+
+  return (
+    <Accordion
+      expanded={expanded}
+      onChange={(_, isExpanded) => {
+        setExpanded(isExpanded);
+      }}
+      sx={{
+        mt: 2,
+        width: "100%",
+        backgroundColor: "#001400",
+        color: "#00ff00",
+      }}
+    >
+      <AccordionSummary
+        expandIcon={<ArrowDropDownIcon sx={{ color: "#00ff00" }} />}
+      >
+        <Typography
+          sx={{
+            color: "#00ff00",
+            fontFamily: "monospace",
+            fontSize: "0.9rem",
+          }}
+        >
+          Logs: {selectedTaskName ?? selectedTaskId}
+        </Typography>
+
+        {!taskCompleted && (
+          <CircularProgress
+            size={14}
+            sx={{
+              color: "rgb(253, 251, 251)",
+              marginLeft: "10px",
+            }}
+          />
+        )}
+
+        {taskCompleted && (
+          <Typography
+            sx={{
+              color: "#ff3333",
+              fontFamily: "monospace",
+              fontSize: "0.75rem",
+              ml: 2,
+              fontWeight: "bold",
+            }}
+          >
+            COMPLETED
+          </Typography>
+        )}
+      </AccordionSummary>
+
+      <AccordionDetails sx={{ p: 0 }}>
+        <Box
+          ref={containerRef}
+          sx={{
+            height: 200,
+            overflowY: "auto",
+            p: 2,
+            bgcolor: "#000",
+            color: "#00ff00",
+            fontFamily: "monospace",
+            fontSize: "10px",
+            whiteSpace: "pre-wrap",
+          }}
+        >
+          {logLines.length === 0 && !taskCompleted && (
+            <Typography>Waiting for log output...</Typography>
+          )}
+
+          {logLines.map((line, index) => {
+            return <Box key={`${selectedTaskId}-${String(index)}`}>{line}</Box>;
+          })}
+        </Box>
+      </AccordionDetails>
+    </Accordion>
+  );
+}
+
+export const TaskLogViewer: React.FC<TaskLogViewerProps> = ({
+  visit,
+  workflowName,
+  selectedTaskId,
+  selectedTaskName,
+}) => {
+  if (!selectedTaskId) {
+    return (
+      <Accordion
+        expanded={false}
+        sx={{
+          mt: 2,
+          width: "100%",
+          backgroundColor: "#001400",
+          color: "#00ff00",
+        }}
+      >
+        <AccordionSummary
+          expandIcon={<ArrowDropDownIcon sx={{ color: "#00ff00" }} />}
+        >
+          <Typography
+            sx={{
+              color: "#00ff00",
+              fontFamily: "monospace",
+              fontSize: "0.9rem",
+            }}
+          >
+            Logs: No task selected
+          </Typography>
+        </AccordionSummary>
+
+        <AccordionDetails sx={{ p: 0 }}>
+          <Box
+            sx={{
+              height: 200,
+              overflowY: "auto",
+              p: 2,
+              bgcolor: "#000",
+              color: "#00ff00",
+              fontFamily: "monospace",
+              fontSize: "10px",
+              whiteSpace: "pre-wrap",
+            }}
+          >
+            <Typography>Select a task.</Typography>
+          </Box>
+        </AccordionDetails>
+      </Accordion>
+    );
+  }
+
+  return (
+    <TaskLogViewerContent
+      key={`${workflowName}-${selectedTaskId}`}
+      visit={visit}
+      workflowName={workflowName}
+      selectedTaskId={selectedTaskId}
+      selectedTaskName={selectedTaskName}
+    />
+  );
+};
+
+export default TaskLogViewer;