diff --git a/.release-please-manifest.json b/.release-please-manifest.json
index cd19e2088..88504beb0 100644
--- a/.release-please-manifest.json
+++ b/.release-please-manifest.json
@@ -1,12 +1,12 @@
 {
   "+1": "0.0.0",
-  "backend/graph-proxy": "0.2.0",
+  "backend/graph-proxy": "0.2.1",
   "+2": "0.0.0",
   "backend/sessionspaces": "0.1.7",
   "+3": "0.0.0",
-  "frontend/dashboard": "0.1.17",
+  "frontend/dashboard": "0.1.18",
   "+4": "0.0.0",
-  "frontend/relay-workflows-lib": "0.1.11",
+  "frontend/relay-workflows-lib": "0.1.12",
   "+5": "0.0.0",
   "frontend/workflows-lib": "0.1.9",
   "frontend/workflows-lib-shared": "0.1.1",
diff --git a/backend/graph-proxy/CHANGELOG.md b/backend/graph-proxy/CHANGELOG.md
index ce046dba4..09b0c968f 100644
--- a/backend/graph-proxy/CHANGELOG.md
+++ b/backend/graph-proxy/CHANGELOG.md
@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.2.1](https://github.com/DiamondLightSource/workflows/compare/graph-proxy@v0.2.0...graph-proxy@v0.2.1) (2026-09-07)
+
+
+### Features
+
+* **graph-proxy:** get active task logs from Argo ([1a565f6](https://github.com/DiamondLightSource/workflows/commit/1a565f6c609ac82f32a1a17a98dda487a2101b2c))
+
 ## [0.2.0](https://github.com/DiamondLightSource/workflows/compare/graph-proxy@v0.1.21...graph-proxy@v0.2.0) (2026-08-27)
 
 
diff --git a/backend/graph-proxy/Cargo.toml b/backend/graph-proxy/Cargo.toml
index beff8e9ec..d994c26e0 100644
--- a/backend/graph-proxy/Cargo.toml
+++ b/backend/graph-proxy/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "graph-proxy"
-version = "0.2.0"
+version = "0.2.1"
 edition = "2021"
 exclude = ["test-assets/"]
 license-file = "../../LICENSE"
diff --git a/backend/graph-proxy/src/graphql/filters.rs b/backend/graph-proxy/src/graphql/filters.rs
index 536b42c57..d690a73ff 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,
 };
@@ -125,21 +126,45 @@ pub struct LabelSelector {
 
 // Workflows--------------------------------------------
 
+/// Represents a workflow parameter filter
+#[derive(Debug, Clone, InputObject)]
+pub struct WorkflowParameterFilter {
+    /// The workflow parameter name
+    #[graphql(name = "parameterName")]
+    parameter_name: 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")]
     labels: Option<Vec<LabelSelector>>,
+
+    /// Workflow parameter key/value filters
+    parameters: Option<Vec<WorkflowParameterFilter>>,
 }
 
 impl WorkflowFilter {
+    /// Returns true when workflow parameter filtering is requested.
+    pub fn has_parameter_filter(&self) -> bool {
+        self.parameters
+            .as_ref()
+            .is_some_and(|parameters| !parameters.is_empty())
+    }
+
     /// Generates and applies all the filters
     pub fn generate_filters(&self, url: &mut Url) {
         let labels = &self.create_label_selection();
@@ -147,7 +172,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();
@@ -160,10 +185,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.parameter_name
+                    && 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)]
@@ -332,15 +375,191 @@ 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(parameter_name: &str, value: &str) -> WorkflowParameterFilter {
+        WorkflowParameterFilter {
+            parameter_name: parameter_name.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,
@@ -351,6 +570,7 @@ mod tests {
         let filters = WorkflowTemplatesFilter {
             science_group: Some(science_groups),
         };
+
         let label_selectors = filters.create_label_selection();
         assert_eq!(
             label_selectors,
@@ -364,6 +584,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();
@@ -379,6 +600,7 @@ mod tests {
         let filters = WorkflowTemplatesFilter {
             science_group: Some(science_groups),
         };
+
         let label_selectors = filters.create_label_selection();
         assert_eq!(
             label_selectors,
@@ -397,6 +619,7 @@ mod tests {
                 operator: WorkflowLabelSelectorOperator::Eq,
                 values: Some(vec!["i14".to_string()]),
             }]),
+            parameters: None,
         };
 
         assert_eq!(filters.create_label_selection(), "beamline=i14");
@@ -415,6 +638,7 @@ mod tests {
                 operator: WorkflowLabelSelectorOperator::Eq,
                 values: Some(vec!["i14".to_string()]),
             }]),
+            parameters: None,
         };
 
         assert_eq!(
@@ -434,6 +658,7 @@ mod tests {
                 operator: WorkflowLabelSelectorOperator::Eq,
                 values: Some(vec!["i14".to_string()]),
             }]),
+            parameters: None,
         };
 
         assert_eq!(filters.create_label_selection(), "beamline=i14");
@@ -448,6 +673,7 @@ mod tests {
             template: None,
             workflow_status_filter: None,
             labels: None,
+            parameters: None,
         };
 
         let labels = filters.create_label_selection();
@@ -467,15 +693,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]
@@ -488,15 +719,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]
@@ -516,9 +752,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/workflows.rs b/backend/graph-proxy/src/graphql/workflows.rs
index 8844a154e..3d846321a 100644
--- a/backend/graph-proxy/src/graphql/workflows.rs
+++ b/backend/graph-proxy/src/graphql/workflows.rs
@@ -617,55 +617,167 @@ impl WorkflowsQuery {
             filter.generate_filters(&mut url);
         }
         let limit = limit.unwrap_or(10);
-        url.query_pairs_mut()
-            .append_pair("listOptions.limit", &limit.to_string());
         let cursor_index = if let Some(cursor) = cursor {
-            let cursor_value = OpaqueCursor::<usize>::decode_cursor(&cursor)
-                .map_err(|_| anyhow::Error::msg("Cursor not valid"))?;
-            url.query_pairs_mut()
-                .append_pair("listOptions.continue", &cursor_value.0.to_string());
-            cursor_value.0
+            OpaqueCursor::<usize>::decode_cursor(&cursor)
+                .map_err(|_| anyhow::Error::msg("Cursor not valid"))?
+                .0
         } else {
             0
         };
+
+        let has_parameter_filter = filter
+            .as_ref()
+            .is_some_and(WorkflowFilter::has_parameter_filter);
+
+        if !has_parameter_filter {
+            url.query_pairs_mut()
+                .append_pair("listOptions.limit", &limit.to_string());
+
+            if cursor_index > 0 {
+                url.query_pairs_mut()
+                    .append_pair("listOptions.continue", &cursor_index.to_string());
+            }
+        }
         debug!("Retrieving workflows name from {url}");
-        let request = if let Some(auth_token) = auth_token {
-            CLIENT.get(url).bearer_auth(auth_token.token())
-        } else {
-            CLIENT.get(url)
-        };
+        // Keep the existing single-page behaviour unless parameter filtering
+        // is requested. Parameter filtering happens client-side because Argo
+        // cannot filter workflow parameters through listOptions.labelSelector.
+        if !has_parameter_filter {
+            let request = if let Some(auth_token) = auth_token {
+                CLIENT.get(url).bearer_auth(auth_token.token())
+            } else {
+                CLIENT.get(url)
+            };
 
-        let api_result = request
-            .send()
-            .await?
-            .json::<APIResult<argo_workflows_openapi::IoArgoprojWorkflowV1alpha1WorkflowList>>()
-            .await?;
-
-        let workflows_response = match api_result.into_result() {
-            Ok(res) => res,
-            Err(err) => {
-                if err.message.as_deref() == Some("Unauthorized") {
-                    return Err(err.into());
+            let api_result = request
+                .send()
+                .await?
+                .json::<APIResult<argo_workflows_openapi::IoArgoprojWorkflowV1alpha1WorkflowList>>()
+                .await?;
+
+            let workflows_response = match api_result.into_result() {
+                Ok(res) => res,
+                Err(err) => {
+                    if err.message.as_deref() == Some("Unauthorized") {
+                        return Err(err.into());
+                    }
+                    return Ok(Connection::new(false, false));
                 }
-                return Ok(Connection::new(false, false));
+            };
+
+            let workflows = workflows_response
+                .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(),
+            );
+
+            connection
+                .edges
+                .extend(workflows.into_iter().enumerate().map(|(idx, workflow)| {
+                    let cursor = OpaqueCursor(cursor_index + idx + 1);
+                    Edge::new(cursor, workflow)
+                }));
+
+            return Ok(connection);
+        }
+
+        // Parameter filtering is client-side, so continue through Argo pages
+        // until we have collected the requested number of matching workflows.
+        // Parameter filtering is client-side, so continue through Argo pages
+        // until we have collected the requested page plus one additional match.
+        // The additional match determines whether another GraphQL page exists.
+        let page_end = cursor_index + limit as usize;
+        let required_matches = page_end + 1;
+
+        let mut matching_workflows = Vec::with_capacity(required_matches);
+        let mut argo_continue: Option<String> = None;
+
+        loop {
+            let mut page_url = url.clone();
+
+            page_url
+                .query_pairs_mut()
+                .append_pair("listOptions.limit", &limit.to_string());
+
+            if let Some(continue_token) = &argo_continue {
+                page_url
+                    .query_pairs_mut()
+                    .append_pair("listOptions.continue", continue_token);
+            }
+
+            let request = if let Some(auth_token) = auth_token {
+                CLIENT.get(page_url).bearer_auth(auth_token.token())
+            } else {
+                CLIENT.get(page_url)
+            };
+
+            let api_result = request
+                .send()
+                .await?
+                .json::<APIResult<argo_workflows_openapi::IoArgoprojWorkflowV1alpha1WorkflowList>>()
+                .await?;
+
+            let workflows_response = match api_result.into_result() {
+                Ok(res) => res,
+                Err(err) => {
+                    if err.message.as_deref() == Some("Unauthorized") {
+                        return Err(err.into());
+                    }
+                    return Ok(Connection::new(false, false));
+                }
+            };
+
+            let next_argo_continue = workflows_response.metadata.continue_;
+
+            if let Some(filter) = &filter {
+                matching_workflows.extend(
+                    workflows_response
+                        .items
+                        .into_iter()
+                        .filter(|workflow| filter.matches_parameters(workflow)),
+                );
             }
-        };
 
-        let workflows = workflows_response
-            .items
+            // We have enough matches to return the requested page and determine
+            // whether another matching workflow exists.
+            if matching_workflows.len() >= required_matches {
+                break;
+            }
+
+            let Some(continue_token) = next_argo_continue else {
+                break;
+            };
+
+            argo_continue = Some(continue_token);
+        }
+
+        // An additional matching workflow after the requested page proves that
+        // another GraphQL page exists.
+        let has_next_page = matching_workflows.len() > page_end;
+
+        // `cursor_index` is the number of matching workflows already consumed.
+        // Parameter-filtered requests are fetched from the beginning, so skip
+        // the workflows belonging to previous GraphQL pages.
+        let workflows = matching_workflows
             .into_iter()
+            .skip(cursor_index)
+            .take(limit as usize)
             .map(|workflow| Workflow::new(workflow, visit.clone().into()))
             .collect::<Vec<_>>();
-        let mut connection = Connection::new(
-            cursor_index > 0,
-            workflows_response.metadata.continue_.is_some(),
-        );
+
+        let mut connection = Connection::new(cursor_index > 0, has_next_page);
         connection
             .edges
             .extend(workflows.into_iter().enumerate().map(|(idx, workflow)| {
                 let cursor = OpaqueCursor(cursor_index + idx + 1);
                 Edge::new(cursor, workflow)
             }));
+
         Ok(connection)
     }
 }
diff --git a/charts/apps/Chart.yaml b/charts/apps/Chart.yaml
index 14a4e0ee3..a0bc94c8a 100644
--- a/charts/apps/Chart.yaml
+++ b/charts/apps/Chart.yaml
@@ -2,4 +2,4 @@ apiVersion: v2
 name: apps
 description: An argocd app to deploy apps inside the virtual cluster
 type: application
-version: 0.5.17
+version: 0.5.20
diff --git a/charts/apps/staging-values.yaml b/charts/apps/staging-values.yaml
index 914930721..95b1e6655 100644
--- a/charts/apps/staging-values.yaml
+++ b/charts/apps/staging-values.yaml
@@ -124,5 +124,6 @@ openbao:
 authBroker:
   enabled: true
   targetRevision: HEAD
-  extraValuesFiles: []
+  extraValueFiles:
+    - staging-values.yaml
   valuesObject: {}
diff --git a/charts/dashboard/Chart.yaml b/charts/dashboard/Chart.yaml
index 2b51af91a..f1b506dc3 100644
--- a/charts/dashboard/Chart.yaml
+++ b/charts/dashboard/Chart.yaml
@@ -2,8 +2,8 @@ apiVersion: v2
 name: dashboard
 description: A dashboard for Diamond workflows
 type: application
-version: 0.3.34
-appVersion: 0.1.17
+version: 0.3.36
+appVersion: 0.1.19
 dependencies:
   - name: common
     version: 2.23.0
diff --git a/charts/graph-proxy/Chart.yaml b/charts/graph-proxy/Chart.yaml
index 7e8928c22..5bf185882 100644
--- a/charts/graph-proxy/Chart.yaml
+++ b/charts/graph-proxy/Chart.yaml
@@ -2,8 +2,8 @@ apiVersion: v2
 name: graph-proxy
 description: A GraphQL proxy for the Argo Workflows Server
 type: application
-version: 0.2.44
-appVersion: 0.2.0
+version: 0.2.47
+appVersion: 0.2.1
 dependencies:
   - name: common
     version: 2.23.0
diff --git a/frontend/dashboard/CHANGELOG.md b/frontend/dashboard/CHANGELOG.md
index 5dce56b24..9f0c53a00 100644
--- a/frontend/dashboard/CHANGELOG.md
+++ b/frontend/dashboard/CHANGELOG.md
@@ -1,5 +1,17 @@
 # Changelog
 
+## [0.1.18](https://github.com/DiamondLightSource/workflows/compare/dashboard@v0.1.17...dashboard@v0.1.18) (2026-09-07)
+
+
+### Features
+
+* **frontend:** add task log viewer ([07a5a36](https://github.com/DiamondLightSource/workflows/commit/07a5a36160914f3078fa69d91ea32bb3004e17cd))
+
+
+### Bug Fixes
+
+* **frontend:** update Relay schema path ([ed28e11](https://github.com/DiamondLightSource/workflows/commit/ed28e119e02ff3092926f16b99dcffea04493a1e))
+
 ## [0.1.17](https://github.com/DiamondLightSource/workflows/compare/dashboard@v0.1.16...dashboard@v0.1.17) (2026-09-03)
 
 
diff --git a/frontend/dashboard/package.json b/frontend/dashboard/package.json
index ac9bb6fb6..21d7f9f56 100644
--- a/frontend/dashboard/package.json
+++ b/frontend/dashboard/package.json
@@ -1,7 +1,7 @@
 {
   "name": "dashboard",
   "private": true,
-  "version": "0.1.17",
+  "version": "0.1.18",
   "type": "module",
   "scripts": {
     "dev": "vite",
diff --git a/frontend/relay-workflows-lib/CHANGELOG.md b/frontend/relay-workflows-lib/CHANGELOG.md
index 0c04f9582..670e36b58 100644
--- a/frontend/relay-workflows-lib/CHANGELOG.md
+++ b/frontend/relay-workflows-lib/CHANGELOG.md
@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.1.12](https://github.com/DiamondLightSource/workflows/compare/relay-workflows-lib@v0.1.11...relay-workflows-lib@v0.1.12) (2026-09-07)
+
+
+### Features
+
+* **frontend:** add task log viewer ([07a5a36](https://github.com/DiamondLightSource/workflows/commit/07a5a36160914f3078fa69d91ea32bb3004e17cd))
+
 ## [0.1.11](https://github.com/DiamondLightSource/workflows/compare/relay-workflows-lib@v0.1.10...relay-workflows-lib@v0.1.11) (2026-09-01)
 
 
diff --git a/frontend/relay-workflows-lib/lib/components/SubmissionForm.tsx b/frontend/relay-workflows-lib/lib/components/SubmissionForm.tsx
index 93c3c4b3e..a41ab4d7a 100644
--- a/frontend/relay-workflows-lib/lib/components/SubmissionForm.tsx
+++ b/frontend/relay-workflows-lib/lib/components/SubmissionForm.tsx
@@ -52,21 +52,24 @@ const SubmissionForm = ({
   workflowId?: string;
 }) => {
   const data = useFragment(SubmissionFormFragment, template);
+
   const repositoryUrl =
     data.repository ?? templateSourceToLink(data.templateSource);
   const reusedParameterData = useFragment(
     SubmissionFormParametersFragment,
     prepopulatedParameters,
   );
+
   const [searchParams] = useSearchParams();
 
+  const parametersSchema = data.arguments as JsonSchema;
+
   const autofilledParameters = mergeParameters(
     reusedParameterData,
     searchParams,
+    parametersSchema,
   );
 
-  const parametersSchema = data.arguments as JsonSchema;
-
   const overriddenKeys = Array.from(new Set(searchParams.keys())).filter(
     (key) => {
       return parametersSchema.properties && key in parametersSchema.properties;
diff --git a/frontend/relay-workflows-lib/lib/utils/workflowRelayUtils.ts b/frontend/relay-workflows-lib/lib/utils/workflowRelayUtils.ts
index 95226850a..10aa4d388 100644
--- a/frontend/relay-workflows-lib/lib/utils/workflowRelayUtils.ts
+++ b/frontend/relay-workflows-lib/lib/utils/workflowRelayUtils.ts
@@ -10,6 +10,7 @@ import {
 } from "../graphql/__generated__/WorkflowTasksFragment.graphql";
 import { JSONObject } from "workflows-lib";
 import { SubmissionFormParametersFragment$data } from "../components/__generated__/SubmissionFormParametersFragment.graphql";
+import { JsonSchema } from "@jsonforms/core";
 
 export function updateSearchParamsWithTaskIds(
   updatedTaskIds: string[],
@@ -95,8 +96,96 @@ export function useFetchedTasks(
 export function mergeParameters(
   reusedParameterData: SubmissionFormParametersFragment$data | null | undefined,
   searchParams: URLSearchParams,
+  parametersSchema?: JsonSchema,
 ) {
-  const searchParameterData = Object.fromEntries(searchParams.entries());
+  const searchParameterData: JSONObject = {};
+  if (!parametersSchema) {
+    return {
+      ...reusedParameterData?.parameters,
+      ...Object.fromEntries(searchParams.entries()),
+    } as JSONObject;
+  }
+
+  for (const [key, value] of searchParams.entries()) {
+    const propertySchema = parametersSchema.properties?.[key];
+
+    // Ignore URL parameters that do not exist in the template schema.
+    if (!propertySchema || typeof propertySchema === "boolean") {
+      continue;
+    }
+
+    if (propertySchema.type === "array" || propertySchema.type === "object") {
+      try {
+        const parsedValue: unknown = JSON.parse(value);
+
+        const hasExpectedType =
+          (propertySchema.type === "array" && Array.isArray(parsedValue)) ||
+          (propertySchema.type === "object" &&
+            parsedValue !== null &&
+            typeof parsedValue === "object" &&
+            !Array.isArray(parsedValue));
+
+        if (!hasExpectedType) {
+          console.warn(
+            `Ignoring URL parameter "${key}": expected ${propertySchema.type}.`,
+          );
+          continue;
+        }
+
+        // Argo workflow parameters are passed as strings.
+        searchParameterData[key] = JSON.stringify(parsedValue);
+      } catch {
+        if (key === "multiEdge") {
+          searchParameterData[key] = [
+            ...value
+              .split(",")
+              .filter(Boolean)
+              .map((edge) => {
+                const [edgeElement, edgeTransition] = edge.split("-");
+
+                return {
+                  edgeElement,
+                  edgeTransition,
+                };
+              }),
+          ];
+
+          continue;
+        }
+
+        if (key === "multiScan") {
+          searchParameterData[key] = [
+            ...value
+              .split(",")
+              .filter(Boolean)
+              .map((scan) => {
+                const [start, end] = scan.split("-");
+
+                return {
+                  multiScan: {
+                    start: Number(start),
+                    end: Number(end),
+                    excluded: [],
+                  },
+                };
+              }),
+          ];
+
+          continue;
+        }
+
+        console.warn(
+          `Ignoring URL parameter "${key}": value is not valid JSON.`,
+        );
+      }
+
+      continue;
+    }
+
+    // Preserve existing behaviour for flat parameters.
+    searchParameterData[key] = value;
+  }
+
   return {
     ...reusedParameterData?.parameters,
     ...searchParameterData,
diff --git a/frontend/relay-workflows-lib/package.json b/frontend/relay-workflows-lib/package.json
index eba8d04aa..f36dd15e3 100644
--- a/frontend/relay-workflows-lib/package.json
+++ b/frontend/relay-workflows-lib/package.json
@@ -1,7 +1,7 @@
 {
   "name": "relay-workflows-lib",
   "private": true,
-  "version": "0.1.11",
+  "version": "0.1.12",
   "type": "module",
   "main": "lib/main.ts",
   "scripts": {
diff --git a/frontend/workflows-lib/lib/components/template/SubmissionForm.tsx b/frontend/workflows-lib/lib/components/template/SubmissionForm.tsx
index f1157ecb4..4ec76f01a 100644
--- a/frontend/workflows-lib/lib/components/template/SubmissionForm.tsx
+++ b/frontend/workflows-lib/lib/components/template/SubmissionForm.tsx
@@ -2,6 +2,7 @@ import { materialCells } from "@jsonforms/material-renderers";
 import { JsonSchema, UISchemaElement, createAjv } from "@jsonforms/core";
 import { JsonForms } from "@jsonforms/react";
 import React, { useState } from "react";
+
 import {
   Box,
   Divider,
@@ -44,12 +45,16 @@ const TemplateSubmissionForm: React.FC<TemplateSubmissionFormProps> = ({
   const theme = useTheme();
   const validator = createAjv({ useDefaults: true, coerceTypes: true });
 
-  const [parameters, setParameters] = useState(prepopulatedParameters ?? {});
+  const [parameters, setParameters] = useState<JSONObject>(
+    prepopulatedParameters ?? {},
+  );
   const [errors, setErrors] = useState<ErrorObject[]>([]);
 
   const [submitted, setSubmitted] = useState(false);
 
   const onClick = (visit: Visit, parameters?: object) => {
+    console.log("SUBMIT PARAMETERS", JSON.stringify(parameters, null, 2));
+
     if (errors.length === 0) {
       onSubmit(visit, parameters ?? {});
       setSubmitted(true);