chore(version): version 0.22.22

closes #10472
closes #7623

.github/workflows/main.yml

@@ -31,6 +31,7 @@ jobs:
   release:
     name: Release
     needs: [tests]
+    if: "!startsWith(github.ref, 'refs/heads/releases')"
     uses: ./.github/workflows/workflow-release.yml
     with:
         plugin-version: ${{ github.event.inputs.plugin-version != null && github.event.inputs.plugin-version || 'LATEST' }}
@@ -42,6 +43,7 @@ jobs:
       SONATYPE_GPG_KEYID: ${{ secrets.SONATYPE_GPG_KEYID }}
       SONATYPE_GPG_PASSWORD: ${{ secrets.SONATYPE_GPG_PASSWORD }}
       SONATYPE_GPG_FILE: ${{ secrets.SONATYPE_GPG_FILE }}
+      GH_PERSONAL_TOKEN: ${{ secrets.GH_PERSONAL_TOKEN }}
 
   end:
     runs-on: ubuntu-latest

.github/workflows/pull-request.yml

@@ -10,7 +10,11 @@ concurrency:
   cancel-in-progress: true
 
 jobs:
+  # ********************************************************************************************************************
+  # File changes detection
+  # ********************************************************************************************************************
   file-changes:
+    if: ${{ github.event.pull_request.draft == false }}
     name: File changes detection
     runs-on: ubuntu-latest
     timeout-minutes: 60
@@ -29,6 +33,9 @@ jobs:
               - '!{ui,.github}/**'
           token: ${{ secrets.GITHUB_TOKEN }}
 
+  # ********************************************************************************************************************
+  # Tests
+  # ********************************************************************************************************************
   frontend:
     name: Frontend - Tests
     needs: [file-changes]

.github/workflows/setversion-tag.yml

@@ -23,12 +23,11 @@ jobs:
             exit 1
           fi
           
-          CURRENT_BRANCH="{{ github.ref }}"
-          
           # Extract the major and minor versions
           BASE_VERSION=$(echo "$RELEASE_VERSION" | sed -E 's/^([0-9]+\.[0-9]+)\..*/\1/')
           RELEASE_BRANCH="refs/heads/releases/v${BASE_VERSION}.x"
           
+          CURRENT_BRANCH="$GITHUB_REF"
           if ! [[ "$CURRENT_BRANCH" == "$RELEASE_BRANCH" ]]; then
             echo "Invalid release branch. Expected $RELEASE_BRANCH, was $CURRENT_BRANCH"
             exit 1

.github/workflows/workflow-github-release.yml

@@ -2,10 +2,6 @@ name: Github - Release
 
 on:
   workflow_call:
-    secrets:
-      GH_PERSONAL_TOKEN:
-        description: "The Github personal token."
-        required: true
 
 jobs:
   publish:
@@ -30,19 +26,4 @@ jobs:
           repo_token: "${{ secrets.GITHUB_TOKEN }}"
           prerelease: false
           files: |
-            build/executable/*
-
-      # Trigger gha workflow to bump helm chart version
-      - name: GitHub - Trigger the Helm chart version bump
-        uses: peter-evans/repository-dispatch@v3
-        if: steps.create_github_release.conclusion == 'success'
-        with:
-          token: ${{ secrets.GH_PERSONAL_TOKEN }}
-          repository: kestra-io/helm-charts
-          event-type: update-helm-chart-version
-          client-payload: |-
-            {
-              "new_version": "${{ github.ref_name }}",
-              "github_repository": "${{ github.repository }}",
-              "github_actor": "${{ github.actor }}"
-            }
+            build/executable/*

.github/workflows/workflow-publish-docker.yml

@@ -8,6 +8,11 @@ on:
         default: 'LATEST'
         required: false
         type: string
+      force-download-artifact:
+        description: 'Force download artifact'
+        required: false
+        type: string
+        default: "true"
   workflow_call:
     inputs:
       plugin-version:
@@ -15,6 +20,11 @@ on:
         default: 'LATEST'
         required: false
         type: string
+      force-download-artifact:
+        description: 'Force download artifact'
+        required: false
+        type: string
+        default: "true"
     secrets:
       DOCKERHUB_USERNAME:
         description: "The Dockerhub username."
@@ -24,25 +34,38 @@ on:
         required: true
 
 jobs:
+  # ********************************************************************************************************************
+  # Build
+  # ********************************************************************************************************************
   build-artifacts:
-    name: Build - Artifacts
+    name: Build Artifacts
+    if: ${{ github.event.inputs.force-download-artifact == 'true' }}
     uses: ./.github/workflows/workflow-build-artifacts.yml
     with:
       plugin-version: ${{ github.event.inputs.plugin-version != null && github.event.inputs.plugin-version || 'LATEST' }}
-
+  # ********************************************************************************************************************
+  # Docker
+  # ********************************************************************************************************************
   publish:
     name: Publish - Docker
-    needs: build-artifacts
     runs-on: ubuntu-latest
+    needs: build-artifacts
+    if: |
+      always() &&
+      (needs.build-artifacts.result == 'success' ||
+        github.event.inputs.force-download-artifact != 'true')
+    env:
+      PLUGIN_VERSION: ${{ github.event.inputs.plugin-version != null && github.event.inputs.plugin-version || 'LATEST' }}
     strategy:
       matrix:
         image:
-          - tag: ${{ needs.build-artifacts.outputs.docker-tag }}-no-plugins
+          - tag: -no-plugins
             packages: jattach
+            plugins: false
             python-libraries: ""
 
-          - tag: ${{ needs.build-artifacts.outputs.docker-tag }}
-            plugins: ${{ needs.build-artifacts.outputs.plugins }}
+          - tag: ""
+            plugins: true
             packages: python3 python3-venv python-is-python3 python3-pip nodejs npm curl zip unzip jattach
             python-libraries: kestra
     steps:
@@ -68,8 +91,17 @@ jobs:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_PASSWORD }}
 
+
+#     # Get Plugins List
+      - name: Plugins - Get List
+        uses: ./.github/actions/plugins-list
+        id: plugins-list
+        if: ${{ matrix.image.plugins}}
+        with:
+          plugin-version: ${{ env.PLUGIN_VERSION }}
+
       # Vars
-      - name: Docker - Set image name
+      - name: Docker - Set variables
         shell: bash
         id: vars
         run: |
@@ -79,6 +111,8 @@ jobs:
           else
             echo "plugins=--repositories=https://s01.oss.sonatype.org/content/repositories/snapshots ${{ matrix.image.plugins }}" >> $GITHUB_OUTPUT
           fi
+          
+          echo "tag=${TAG}${{ matrix.image.tag }}" >> $GITHUB_OUTPUT
 
       # Build Docker Image
       - name: Artifacts - Download executable
@@ -98,7 +132,7 @@ jobs:
         with:
           context: .
           push: true
-          tags: kestra/kestra:${{ matrix.image.tag }}
+          tags: kestra/kestra:${{ steps.vars.outputs.tag }}
           platforms: linux/amd64,linux/arm64
           build-args: |
             KESTRA_PLUGINS=${{ steps.vars.outputs.plugins }}

.github/workflows/workflow-publish-maven.yml

@@ -39,8 +39,8 @@ jobs:
       - name: Publish - Release package to Maven Central
         shell: bash
         env:
-          ORG_GRADLE_PROJECT_sonatypeUsername: ${{ secrets.SONATYPE_USER }}
-          ORG_GRADLE_PROJECT_sonatypePassword: ${{ secrets.SONATYPE_PASSWORD }}
+          ORG_GRADLE_PROJECT_mavenCentralUsername: ${{ secrets.SONATYPE_USER }}
+          ORG_GRADLE_PROJECT_mavenCentralPassword: ${{ secrets.SONATYPE_PASSWORD }}
           SONATYPE_GPG_KEYID: ${{ secrets.SONATYPE_GPG_KEYID }}
           SONATYPE_GPG_PASSWORD: ${{ secrets.SONATYPE_GPG_PASSWORD }}
           SONATYPE_GPG_FILE: ${{ secrets.SONATYPE_GPG_FILE}}
@@ -50,7 +50,7 @@ jobs:
           echo "signing.password=${SONATYPE_GPG_PASSWORD}" >> ~/.gradle/gradle.properties
           echo "signing.secretKeyRingFile=${HOME}/.gradle/secring.gpg" >> ~/.gradle/gradle.properties
           echo ${SONATYPE_GPG_FILE} | base64 -d > ~/.gradle/secring.gpg
-          ./gradlew publishToSonatype ${{ startsWith(github.ref, 'refs/tags/v')  && 'closeAndReleaseSonatypeStagingRepository' || '' }}
+          ./gradlew publishToMavenCentral
 
       # Gradle dependency
       - name: Java - Gradle dependency graph

.github/workflows/workflow-release.yml

@@ -8,6 +8,11 @@ on:
         default: 'LATEST'
         required: false
         type: string
+      publish-docker:
+        description: "Publish Docker image"
+        default: 'false'
+        required: false
+        type: string
   workflow_call:
     inputs:
       plugin-version:
@@ -37,10 +42,24 @@ on:
       SONATYPE_GPG_FILE:
         description: "The Sonatype GPG file."
         required: true
+      GH_PERSONAL_TOKEN:
+        description: "The Github personal token."
+        required: true
 jobs:
+  build-artifacts:
+    name: Build - Artifacts
+    uses: ./.github/workflows/workflow-build-artifacts.yml
+    with:
+      plugin-version: ${{ github.event.inputs.plugin-version != null && github.event.inputs.plugin-version || 'LATEST' }}
+
   Docker:
     name: Publish Docker
+    needs: build-artifacts
     uses: ./.github/workflows/workflow-publish-docker.yml
+    if: startsWith(github.ref, 'refs/heads/develop') || github.event.inputs.publish-docker == 'true'
+    with:
+      force-download-artifact: 'false'
+      plugin-version: ${{ github.event.inputs.plugin-version != null && github.event.inputs.plugin-version || 'LATEST' }}
     secrets:
       DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
       DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
@@ -57,7 +76,6 @@ jobs:
 
   Github:
     name: Github Release
+    needs: build-artifacts
     if: startsWith(github.ref, 'refs/tags/v')
-    uses: ./.github/workflows/workflow-github-release.yml
-    secrets:
-      GH_PERSONAL_TOKEN: ${{ secrets.GH_PERSONAL_TOKEN }}
+    uses: ./.github/workflows/workflow-github-release.yml

.plugins

@@ -59,6 +59,7 @@
 #plugin-jira:io.kestra.plugin:plugin-jira:LATEST
 #plugin-kafka:io.kestra.plugin:plugin-kafka:LATEST
 #plugin-kubernetes:io.kestra.plugin:plugin-kubernetes:LATEST
+#plugin-ldap:io.kestra.plugin:plugin-langchain4j:LATEST
 #plugin-ldap:io.kestra.plugin:plugin-ldap:LATEST
 #plugin-linear:io.kestra.plugin:plugin-linear:LATEST
 #plugin-malloy:io.kestra.plugin:plugin-malloy:LATEST

CHANGELOG.md

@@ -0,0 +1,849 @@
+# 0.22.2
+
+**Full Changelog**: [v0.22.1....v0.22.2](https://github.com/kestra-io/kestra/compare/v0.22.1...v0.22.2)
+
+### 🚀 Enhancements
+
+- **jdbc:** Allow disabling queue cleaning. ([a63dbe8e8](https://github.com/kestra-io/kestra/commit/a63dbe8e8))
+- **jdbc-h2,jdbc-mysql,jdbc-postgres:** Add an index on queues.key ([412837952](https://github.com/kestra-io/kestra/commit/412837952))
+- **ui:** Ability to hide secret value when typing in secrets ([59cc56186](https://github.com/kestra-io/kestra/commit/59cc56186))
+
+### 🩹 Fixes
+
+- **core:** Default namespace in namespace file ([ffd06a57e](https://github.com/kestra-io/kestra/commit/ffd06a57e))
+- **ui:** Prevent infinite loading loop in Namespace KV Store & Secrets pages if there is none ([8fb6e6af2](https://github.com/kestra-io/kestra/commit/8fb6e6af2))
+- **ui:** Amend namespace files creation & editing problems ([#8279](https://github.com/kestra-io/kestra/pull/8279))
+- **core:** Fix NPE when generating flow graph ([37ef0a8b3](https://github.com/kestra-io/kestra/commit/37ef0a8b3))
+
+### 🏡 Chore
+
+- **version:** Update the CHANGELOG.MD with details for 0.22.1 ([120d06454](https://github.com/kestra-io/kestra/commit/120d06454))
+- **ui:** Amend the sizing of editor panels ([#8277](https://github.com/kestra-io/kestra/pull/8277))
+- **ui:** Pass prop to maximize the height of namespace file editor ([#8278](https://github.com/kestra-io/kestra/pull/8278))
+- Upgrade to 0.22.2 ([546d5478d](https://github.com/kestra-io/kestra/commit/546d5478d))
+
+### ❤️ Contributors
+
+- Brian.mulier ([@brian-mulier-p](https://github.com/brian-mulier-p))
+- Florian Hussonnois ([@fhussonnois](https://github.com/fhussonnois))
+- Miloš Paunović ([@MilosPaunovic](https://github.com/MilosPaunovic))
+- Loïc Mathieu ([@loicmathieu](https://github.com/loicmathieu))
+
+
+
+# 0.22.1
+
+**Full Changelog**: [v0.22.0....v0.22.1](https://github.com/kestra-io/kestra/compare/v0.22.0...v0.22.1)
+
+### 🚀 Enhancements
+
+- Add afterExecution to basic.md ([#8126](https://github.com/kestra-io/kestra/pull/8126))
+
+### 🩹 Fixes
+
+- **cli**: prevent FlowUpdatesCommand to crash due to plugin loader ([YannC](https://github.com/kestra-io/kestra/commit/3ce2cdaeb915d98debfb635215d8604abbc869c2))
+- **core:** Use a stable flow logger name ([7cfbb91e7](https://github.com/kestra-io/kestra/commit/7cfbb91e7))
+- **core:** HttpClient log the URL even if it's a secret" ([ae223c8d7](https://github.com/kestra-io/kestra/commit/ae223c8d7))
+- **core:** Mask secrets on log attributes ([94dcba126](https://github.com/kestra-io/kestra/commit/94dcba126))
+- **ui:** Keep fetching if filtered kvs & secrets have no elements after fetch ([5757b576e](https://github.com/kestra-io/kestra/commit/5757b576e))
+- **gradle:** Windows selfrun.bat ([9cb51ba0e](https://github.com/kestra-io/kestra/commit/9cb51ba0e))
+- **jdbc:** Possible deadlock on service instance ([6ead4e63c](https://github.com/kestra-io/kestra/commit/6ead4e63c))
+- **cli:** Fix NPE for commands not requiring plugins ([#8212](https://github.com/kestra-io/kestra/pull/8212))
+- **core:** Be tolerant of decryption issue ([38f68dae5](https://github.com/kestra-io/kestra/commit/38f68dae5))
+- **jdbc:** #8219 unquoted timestamp field breaking query ([#8222](https://github.com/kestra-io/kestra/pull/8222), [#8219](https://github.com/kestra-io/kestra/issues/8219))
+
+### 🏡 Chore
+
+- **version:** Update the CHANGELOG.MD with details for 0.22.0 ([b78748ebf](https://github.com/kestra-io/kestra/commit/b78748ebf))
+- **ci:** Modify publish docker to align on EE ([fedbffbdf](https://github.com/kestra-io/kestra/commit/fedbffbdf))
+- **ci:** Align plugins handle for docker publish on EE CI ([632c5836d](https://github.com/kestra-io/kestra/commit/632c5836d))
+- ae223c8: Revert "fix(core): HttpClient log the URL even if it's a secret" (Loïc Mathieu)
+- Upgrade to 0.22.1 ([9857930da](https://github.com/kestra-io/kestra/commit/9857930da))
+
+### ❤️ Contributors
+
+- Loïc Mathieu ([@loicmathieu](https://github.com/loicmathieu))
+- Nicolas K. <nk_mikmak@hotmail.com>
+- YannC <ycoornaert@kestra.io>
+- Florian Hussonnois ([@fhussonnois](https://github.com/fhussonnois))
+- Shruti Mantri <shruti1810@gmail.com>
+- MilosPaunovic ([@MilosPaunovic](https://github.com/MilosPaunovic))
+- Brian.mulier ([@brian-mulier-p](https://github.com/brian-mulier-p))
+
+
+
+# 0.22.0
+
+**Full Changelog**: [v0.21.0...v0.22.0](https://github.com/kestra-io/kestra/compare/v0.21.0...v0.22.0)
+
+### 🚀 Enhancements
+
+- **ui:** Don't show deprecated tasks in the plugins list ([8d00c8a55](https://github.com/kestra-io/kestra/commit/8d00c8a55))
+- **webserver:** If no date provided for dashboard, then use default timewindow ([b86b4bb16](https://github.com/kestra-io/kestra/commit/b86b4bb16))
+- Add a shadow to cards ([#7038](https://github.com/kestra-io/kestra/pull/7038))
+- **ui:** Multiple improvements of no code editor ([#7076](https://github.com/kestra-io/kestra/pull/7076))
+- **ui:** Display attempts status on taskrun on left ([84447fd42](https://github.com/kestra-io/kestra/commit/84447fd42))
+- **ui:** Improve the task array component ([#7095](https://github.com/kestra-io/kestra/pull/7095))
+- Show a lock on EE only pages ([#7093](https://github.com/kestra-io/kestra/pull/7093))
+- **ui:** Allow task re-ordering from no code editor ([#7120](https://github.com/kestra-io/kestra/pull/7120))
+- **ui:** Add finally block to no code editor ([#7123](https://github.com/kestra-io/kestra/pull/7123))
+- **build:** Add script to makefile ([#7125](https://github.com/kestra-io/kestra/pull/7125))
+- **ui:** Add a link to the filtered Executions table. ([#7129](https://github.com/kestra-io/kestra/pull/7129))
+- **ui:** Multiple improvements of no code editor ([#7146](https://github.com/kestra-io/kestra/pull/7146))
+- **core:** New Publish task for metrics ([#7122](https://github.com/kestra-io/kestra/pull/7122))
+- **jdbc-*:** Delete subflow_executions table ([671eb2b57](https://github.com/kestra-io/kestra/commit/671eb2b57))
+- **ui:** Add keyboard shortcuts dialog to editor ([#6628](https://github.com/kestra-io/kestra/pull/6628))
+- **ui:** Now display an error when SSE failed ([#7177](https://github.com/kestra-io/kestra/pull/7177))
+- **ui:** Docs markdown alert styled based on alert level in product. ([#6818](https://github.com/kestra-io/kestra/pull/6818))
+- **ui:** Add option to choose visible columns in flow and execution listings ([#6932](https://github.com/kestra-io/kestra/pull/6932))
+- Theme switch to "theme switch" the charts ([#7151](https://github.com/kestra-io/kestra/pull/7151))
+- **ui:** Add script to help with creation of release notes ([#7212](https://github.com/kestra-io/kestra/pull/7212))
+- **core:** Allow loading secrets from a different namspace ([21aebe4e7](https://github.com/kestra-io/kestra/commit/21aebe4e7))
+- **webserver:** Optimize queue usage for follow endpoints ([13be8b812](https://github.com/kestra-io/kestra/commit/13be8b812))
+- **webserver:** Improvement to ExecutionStreaminService ([4c401ce0c](https://github.com/kestra-io/kestra/commit/4c401ce0c))
+- **cicd:** Codecov + tests report ([03dccd144](https://github.com/kestra-io/kestra/commit/03dccd144))
+- **cicd:** Add codecov bundle analysis ([ab2a0108a](https://github.com/kestra-io/kestra/commit/ab2a0108a))
+- **webserver:** Use a shared queue consumer from the log follow endpoint ([2a95aee96](https://github.com/kestra-io/kestra/commit/2a95aee96))
+- **core:** Add sanity check to request task ([#7230](https://github.com/kestra-io/kestra/pull/7230))
+- **ci:** Add workflows for release process ([480fc7589](https://github.com/kestra-io/kestra/commit/480fc7589))
+- **cicd:** Add codecov flags ([3f429ef0a](https://github.com/kestra-io/kestra/commit/3f429ef0a))
+- **core:** Simplify Pebble error messages ([1eacb447d](https://github.com/kestra-io/kestra/commit/1eacb447d))
+- **cicd:** Add unit test for js ([#7246](https://github.com/kestra-io/kestra/pull/7246))
+- **cicd:** Add test analysis on frontend ([123f74803](https://github.com/kestra-io/kestra/commit/123f74803))
+- **cicd:** Don't mark failed for front end test ([1bbe0e659](https://github.com/kestra-io/kestra/commit/1bbe0e659))
+- **cicd:** Restore codeql weekly ([0c3ed3b75](https://github.com/kestra-io/kestra/commit/0c3ed3b75))
+- **core, jdbc:** Directly process WorkerTaskResult from flowable tasks ([be1871430](https://github.com/kestra-io/kestra/commit/be1871430))
+- **ui:** Center view when switching between topology modes ([#7257](https://github.com/kestra-io/kestra/pull/7257))
+- Give blueprint pages a distinct name ([#7254](https://github.com/kestra-io/kestra/pull/7254))
+- **core:** Added FileEmpty & FileExists Pebble Functions ([88a5cd69e](https://github.com/kestra-io/kestra/commit/88a5cd69e))
+- **jdbc:** Purge execution queue early ([dd8ae5e64](https://github.com/kestra-io/kestra/commit/dd8ae5e64))
+- **jdbc:** Puerge worker task result queue early ([31d221241](https://github.com/kestra-io/kestra/commit/31d221241))
+- **jdbc:** Purge worker job queue early ([e7f551edc](https://github.com/kestra-io/kestra/commit/e7f551edc))
+- **core:** Add system.correlationId label to triggered executions ([ed1449363](https://github.com/kestra-io/kestra/commit/ed1449363))
+- **jdbc:** Queues.updated should be set when the record is updated ([9d717caf9](https://github.com/kestra-io/kestra/commit/9d717caf9))
+- **jdbc:** Clean more eagerly some queues based on configuration ([13ac335c9](https://github.com/kestra-io/kestra/commit/13ac335c9))
+- **core, jdbc:** Use an elastic thread pool ([f8a6e3fb0](https://github.com/kestra-io/kestra/commit/f8a6e3fb0))
+- **jdbc:** Consume multiple times the execution and worker task result queues ([41712b8d8](https://github.com/kestra-io/kestra/commit/41712b8d8))
+-  ([#7389](https://github.com/kestra-io/kestra/pull/7389))
+-  ([#7432](https://github.com/kestra-io/kestra/pull/7432))
+- **ui:** Add keyboard shortcuts for changing editor font size ([#7450](https://github.com/kestra-io/kestra/pull/7450))
+- **ui:** Introduce topology export to image files ([#7541](https://github.com/kestra-io/kestra/pull/7541))
+- Add plugin search command ([e7950279b](https://github.com/kestra-io/kestra/commit/e7950279b))
+- **ui:** Improve inspecting details of multiple executions ([#7516](https://github.com/kestra-io/kestra/pull/7516))
+- **ui:** Add ability to have persistent filter options ([#7276](https://github.com/kestra-io/kestra/pull/7276))
+- Add full examples for datetimebetween condition ([#7598](https://github.com/kestra-io/kestra/pull/7598))
+- **ui:** Introduce the execution timeline section on overview tab ([#7498](https://github.com/kestra-io/kestra/pull/7498))
+- **ui:** Make filter dropdown be positioned below the input caret ([#7614](https://github.com/kestra-io/kestra/pull/7614))
+- **core:** Enhance plugin management ([a098847c6](https://github.com/kestra-io/kestra/commit/a098847c6))
+- **ui:** Allow reordering tabs in the editor ([#7531](https://github.com/kestra-io/kestra/pull/7531))
+- **core:** Improve performance of ExecutorService.handleChildWorkerTaskResult ([fa07cbd3b](https://github.com/kestra-io/kestra/commit/fa07cbd3b))
+- **#7636:** Add default options for HttpClient ([5b42d0adb](https://github.com/kestra-io/kestra/commit/5b42d0adb))
+- **#7636:** Add default options for HttpClient" ([7ccb97a96](https://github.com/kestra-io/kestra/commit/7ccb97a96))
+- **core:** Replace new ArrayList by Collections.emptyList() ([ff3f90465](https://github.com/kestra-io/kestra/commit/ff3f90465))
+- **core:** Use HashMap.newHashMap(int) ([677585213](https://github.com/kestra-io/kestra/commit/677585213))
+- **core:** Improve merging outputs by merging them at the task level ([8c708e2d5](https://github.com/kestra-io/kestra/commit/8c708e2d5))
+- Add examples for conditions - 3 ([#7657](https://github.com/kestra-io/kestra/pull/7657))
+- Add examples for flow conditions ([#7659](https://github.com/kestra-io/kestra/pull/7659))
+- Add example for expression condition ([#7660](https://github.com/kestra-io/kestra/pull/7660))
+- **#7636:** Add default options for HttpClient ([#7650](https://github.com/kestra-io/kestra/pull/7650))
+- **core, jdbc:** DashboardRepository.findAll() ([cd97705d8](https://github.com/kestra-io/kestra/commit/cd97705d8))
+- **ui:** Add markdown formatting to flow run dialog ([#7663](https://github.com/kestra-io/kestra/pull/7663))
+- **core, jdbc:** Dynamic worker group key ([2c63112a5](https://github.com/kestra-io/kestra/commit/2c63112a5))
+- **core-ee:** #2838 add audit log shipper ([#7701](https://github.com/kestra-io/kestra/pull/7701), [#2838](https://github.com/kestra-io/kestra/issues/2838))
+- **core:** Allow reading file from any namespaces ([dfe5552a1](https://github.com/kestra-io/kestra/commit/dfe5552a1))
+- **core:** Add new crudEventType value ([f7e61a46d](https://github.com/kestra-io/kestra/commit/f7e61a46d))
+- **core:** #7721 add namespace to pebble file functions ([#7729](https://github.com/kestra-io/kestra/pull/7729), [#7721](https://github.com/kestra-io/kestra/issues/7721))
+- **webserver:** Mask the secret() function result from eval outputs ([88341bb5c](https://github.com/kestra-io/kestra/commit/88341bb5c))
+- **core:** Handle worker group fallback inside the scheduler ([e9f2711cd](https://github.com/kestra-io/kestra/commit/e9f2711cd))
+- **core:** #5467 add namespaces in the namespaceFiles parameter ([#7749](https://github.com/kestra-io/kestra/pull/7749), [#5467](https://github.com/kestra-io/kestra/issues/5467))
+- **core:** Add outputs to the Flow trigger ([1692cab53](https://github.com/kestra-io/kestra/commit/1692cab53))
+- **core:** Custom log filter ([3ef11044a](https://github.com/kestra-io/kestra/commit/3ef11044a))
+- **core-ee:** Add json format to file log exporter ([#7789](https://github.com/kestra-io/kestra/pull/7789))
+- **ui:** Introduce kv() and secret() pebble autocompletions ([a064c7a95](https://github.com/kestra-io/kestra/commit/a064c7a95))
+- **core:** Add execution state in Pebbe context ([d0af5767d](https://github.com/kestra-io/kestra/commit/d0af5767d))
+- **core:** AfterExecution tasks ([39b8fc103](https://github.com/kestra-io/kestra/commit/39b8fc103))
+- **core,jdbc:** Switch back to a cached thread pool for async JDBC queue ([c2e62d653](https://github.com/kestra-io/kestra/commit/c2e62d653))
+- **build:** Configure heap size to max 50% of available memory ([#7800](https://github.com/kestra-io/kestra/pull/7800))
+- **core:** Redact KESTRA_JAVA_OPTS from the env available to executions ([ecfe925ec](https://github.com/kestra-io/kestra/commit/ecfe925ec))
+- Add finally to the flow assets in basic.md ([#7857](https://github.com/kestra-io/kestra/pull/7857))
+- **core:** Add afterExecution to the topology ([f7019af9d](https://github.com/kestra-io/kestra/commit/f7019af9d))
+- **ui:** Add `afterExecution` block to no code editor ([#7848](https://github.com/kestra-io/kestra/pull/7848))
+- **cli:** Add new --all option to plugin install cmd ([#7375](https://github.com/kestra-io/kestra/pull/7375))
+- **core:** Add Kestra env name and URL to the expression context ([1ba54cd08](https://github.com/kestra-io/kestra/commit/1ba54cd08))
+- **webserver:** Add Kestra URL to the config endpoint ([70e6d47c1](https://github.com/kestra-io/kestra/commit/70e6d47c1))
+- **ui:** Add copy button to kv store listing rows ([#7907](https://github.com/kestra-io/kestra/pull/7907))
+- **ui:** Implement a default tab setting for flows ([#7917](https://github.com/kestra-io/kestra/pull/7917))
+- ⚠️  Make kv pebble function raise error by default ([#7855](https://github.com/kestra-io/kestra/pull/7855))
+- **ui:** Add the option to copy single/all logs to clipboard ([#7755](https://github.com/kestra-io/kestra/pull/7755))
+- **ui:** Add beta badge global component ([#7934](https://github.com/kestra-io/kestra/pull/7934))
+- **model, core:** Document tasks props that are internal storage URI ([745c64c4b](https://github.com/kestra-io/kestra/commit/745c64c4b))
+- **core:** Add correlationId to the Flow trigger ([a7433c6f6](https://github.com/kestra-io/kestra/commit/a7433c6f6))
+- ***:** Allow disabling flow logs and use a specific logger for executions, tasks and triggers ([11a166486](https://github.com/kestra-io/kestra/commit/11a166486))
+- **core:** Require existing namespace ([6194f244c](https://github.com/kestra-io/kestra/commit/6194f244c))
+- **ui:** Introduce global KV Store view ([ab7788aea](https://github.com/kestra-io/kestra/commit/ab7788aea))
+- **core:** Allow null or empty proxy address to bypass proxy conf ([73c7a2d3d](https://github.com/kestra-io/kestra/commit/73c7a2d3d))
+- **core:** Speed up namespace file download and add a log & metrics ([f29aab071](https://github.com/kestra-io/kestra/commit/f29aab071))
+- **core:** #7932 add file exist comportment to NamespaceFiles ([#7979](https://github.com/kestra-io/kestra/pull/7979), [#7932](https://github.com/kestra-io/kestra/issues/7932))
+- **core:** Add new subkey arg to secret pebble function ([0987d0b34](https://github.com/kestra-io/kestra/commit/0987d0b34))
+- Multi panel editor without the refactor ([#7971](https://github.com/kestra-io/kestra/pull/7971))
+- Parse docs is 2 steps to avoid user waiting with nothing ([#7149](https://github.com/kestra-io/kestra/pull/7149))
+- **core,jdbc:** Reset the trigger inside the JdbcExecutor ([4a3d6b30d](https://github.com/kestra-io/kestra/commit/4a3d6b30d))
+- **ui:** Introduce global Secrets page ([d9ac26716](https://github.com/kestra-io/kestra/commit/d9ac26716))
+- **docs:** Add example for best practice with multiline json http post request ([#8023](https://github.com/kestra-io/kestra/pull/8023))
+- **core:** #5467 add inheritance for KV in pebble and Get task ([#8031](https://github.com/kestra-io/kestra/pull/8031), [#5467](https://github.com/kestra-io/kestra/issues/5467))
+- Cleaner multipanel tab move ([#8029](https://github.com/kestra-io/kestra/pull/8029))
+- **ui:** Improve styling of saved filter searches ([#8040](https://github.com/kestra-io/kestra/pull/8040))
+- ***:** Add new methods findAllAsync for the backup ([c965f2f64](https://github.com/kestra-io/kestra/commit/c965f2f64))
+- **core-ee:** #7501 split file log exporter to multiple files ([#8138](https://github.com/kestra-io/kestra/pull/8138), [#7501](https://github.com/kestra-io/kestra/issues/7501))
+
+### 🩹 Fixes
+
+- **cli:** Flow watcher should compute plugin defaults ([07dfaada9](https://github.com/kestra-io/kestra/commit/07dfaada9))
+- **ui:** Dynamic format date ([d17fe2548](https://github.com/kestra-io/kestra/commit/d17fe2548))
+- Namespaces should have the card background ([b8fac95e1](https://github.com/kestra-io/kestra/commit/b8fac95e1))
+- **styles:** Remove background color from edit buttons ([#7037](https://github.com/kestra-io/kestra/pull/7037))
+- Use proper css variables for table colors ([#7049](https://github.com/kestra-io/kestra/pull/7049))
+- Remove default variables for box-shadow ([f1b294065](https://github.com/kestra-io/kestra/commit/f1b294065))
+- Color of tags in executions list ([#7035](https://github.com/kestra-io/kestra/pull/7035))
+- **core:** RestartForEachItem() is flaky ([6afdbb01f](https://github.com/kestra-io/kestra/commit/6afdbb01f))
+- **script:** AbstractExecScript.injectDefaults should throw IllegalVariableEvaluationException ([2777b3438](https://github.com/kestra-io/kestra/commit/2777b3438))
+- **cli:** Repeate flaky tests FileChangedEventListenerTest ([03caf3825](https://github.com/kestra-io/kestra/commit/03caf3825))
+- **demo:** Make button clickable with utm link ([491546557](https://github.com/kestra-io/kestra/commit/491546557))
+- Remove the topbar from namepasce/flows ([accbafe13](https://github.com/kestra-io/kestra/commit/accbafe13))
+- Remove some warnings ([7a299e51f](https://github.com/kestra-io/kestra/commit/7a299e51f))
+- **ui:** Amend no code editor breadcrumbs issue ([#7054](https://github.com/kestra-io/kestra/pull/7054))
+- **docs:** Remove custom dashboard website component ([e1a4f2e2f](https://github.com/kestra-io/kestra/commit/e1a4f2e2f))
+- Unlock audit logs in execution ([157566300](https://github.com/kestra-io/kestra/commit/157566300))
+- Transfer utm parameters correctly ([0e09f6821](https://github.com/kestra-io/kestra/commit/0e09f6821))
+- **ui:** Fix missing param kind for blueprint in flow editor ([#7087](https://github.com/kestra-io/kestra/pull/7087))
+- **core:** Subflow validation didn't work anymore ([9b2c4c9a1](https://github.com/kestra-io/kestra/commit/9b2c4c9a1))
+- **core:** Retry flaky test AbstractRunnerTest.multipleConditionTriggerFailed() ([db4f186bd](https://github.com/kestra-io/kestra/commit/db4f186bd))
+- **core:** Http request with head and 404 and sending the wrong exception ([6ee0e86ca](https://github.com/kestra-io/kestra/commit/6ee0e86ca))
+- **cli:** Retry flaky test FlowCreateOrUpdateCommandTest.runWithDelete. ([96f4466f1](https://github.com/kestra-io/kestra/commit/96f4466f1))
+- **core:** Subflow labels must not be overriden by parent flow ones ([6190d9113](https://github.com/kestra-io/kestra/commit/6190d9113))
+- Use the new charts in the flows page ([#6970](https://github.com/kestra-io/kestra/pull/6970))
+- Plugin header icon for ticket #4252 ([#4252](https://github.com/kestra-io/kestra/issues/4252))
+- Make sure normal single line table dont' push the build #7018 ([#7018](https://github.com/kestra-io/kestra/issues/7018))
+- **core:** Retry flaky test TimeoutTest.timeout() ([4e753c7b9](https://github.com/kestra-io/kestra/commit/4e753c7b9))
+- Protect axios JSON parsing ([a4dcb8dcd](https://github.com/kestra-io/kestra/commit/a4dcb8dcd))
+- Remove FE warnings on flow edition ([65dd4f9fd](https://github.com/kestra-io/kestra/commit/65dd4f9fd))
+- Remove Labels tag type warning ([3a8b24eda](https://github.com/kestra-io/kestra/commit/3a8b24eda))
+- Avoid clearing selected value on every error ([631a016e0](https://github.com/kestra-io/kestra/commit/631a016e0))
+- **ui:** Remove useless double click row action ([e527f0133](https://github.com/kestra-io/kestra/commit/e527f0133))
+- **ci:** Update scripts/workflows for plugins ([555b769aa](https://github.com/kestra-io/kestra/commit/555b769aa))
+- Use the proper variable for select header in table ([#7107](https://github.com/kestra-io/kestra/pull/7107))
+- Make table links primary instead of purple ([#7106](https://github.com/kestra-io/kestra/pull/7106))
+- **ui:** Restore namespace filter manual typing & various improvements ([#7127](https://github.com/kestra-io/kestra/pull/7127))
+- **core:** Remove the dynamic property patterns ([e6827f273](https://github.com/kestra-io/kestra/commit/e6827f273))
+- **cli:** Print help on missing parameters ([ae05de4a1](https://github.com/kestra-io/kestra/commit/ae05de4a1))
+- **ui:** Amend log lines in Firefox ([#7133](https://github.com/kestra-io/kestra/pull/7133))
+- Enterprise edition tag in light mode ([85ebf49b6](https://github.com/kestra-io/kestra/commit/85ebf49b6))
+- Sidemenu bring back the gray hover ([e15eb5587](https://github.com/kestra-io/kestra/commit/e15eb5587))
+- **ui:** Get the string fields in no code to use editor and have auto completion back ([#7150](https://github.com/kestra-io/kestra/pull/7150))
+- **ui:** Switching from custom Flow blueprints tab to dashboard was not working ([fa5ef3b4c](https://github.com/kestra-io/kestra/commit/fa5ef3b4c))
+- **ui:** Custom Dashboard name overflows. ([#7124](https://github.com/kestra-io/kestra/pull/7124))
+- Setup docId for blueprints ([9499ee2c2](https://github.com/kestra-io/kestra/commit/9499ee2c2))
+- Bring back hover in main menu ([1bbe48fe5](https://github.com/kestra-io/kestra/commit/1bbe48fe5))
+- **core:** Process runner are not serialized correctly on worker ([c91827610](https://github.com/kestra-io/kestra/commit/c91827610))
+- **ui:** Amend pagination on namespace flows listing ([#7163](https://github.com/kestra-io/kestra/pull/7163))
+- **core:** Retry flaky test AbstractRunnerTest.restartFailedThenFailureWithGlobalErrors ([560703fde](https://github.com/kestra-io/kestra/commit/560703fde))
+- **ui:** Null-safe search filters ([21733d849](https://github.com/kestra-io/kestra/commit/21733d849))
+- **core:** Retry flaky test AbstractRunnereTest.concurrencyQueuePause ([f8b64cfbd](https://github.com/kestra-io/kestra/commit/f8b64cfbd))
+- **ui:** Amend translation string for no results ([#7172](https://github.com/kestra-io/kestra/pull/7172))
+- **ui:** Align dashboard button label to icon ([#7175](https://github.com/kestra-io/kestra/pull/7175))
+- **core:** Retry test HttpClientTest.getText ([20d55122e](https://github.com/kestra-io/kestra/commit/20d55122e))
+- **core:** Retry flaky test AbstractRunnerTest.restartForEachItem ([30db740de](https://github.com/kestra-io/kestra/commit/30db740de))
+- **core:** Make flow/namespace variables available for input expr ([8d8b7e7a6](https://github.com/kestra-io/kestra/commit/8d8b7e7a6))
+- **ui:** Global plugin doc with new redesign + auto-expand properties initially ([bbb03b288](https://github.com/kestra-io/kestra/commit/bbb03b288))
+- **theme:** Make plugin rendering reactive to theme switch ([9619dca76](https://github.com/kestra-io/kestra/commit/9619dca76))
+- **core:** #7181 log level rendered as string ([#7198](https://github.com/kestra-io/kestra/pull/7198), [#7181](https://github.com/kestra-io/kestra/issues/7181))
+- **core:** Request option doesn't initialize properly ([a0483dc20](https://github.com/kestra-io/kestra/commit/a0483dc20))
+- **ui:** Prevent doubling the executions chart on flow overview ([#7219](https://github.com/kestra-io/kestra/pull/7219))
+- **core:** Possible NPE on LabelService.containsAll ([ecd36ec2a](https://github.com/kestra-io/kestra/commit/ecd36ec2a))
+- **ui:** Amend the language switching issue ([#7235](https://github.com/kestra-io/kestra/pull/7235))
+- Add comment on i18n code ([e0ee26a9c](https://github.com/kestra-io/kestra/commit/e0ee26a9c))
+- Labels should not be purple if inactive ([95b94f396](https://github.com/kestra-io/kestra/commit/95b94f396))
+- **webserver,core:** Move the LogStreamService in core so EE can use it for apps ([84c07ef01](https://github.com/kestra-io/kestra/commit/84c07ef01))
+- **ci:** Fix and remove unecessary setps in set version workflows ([dc8576afe](https://github.com/kestra-io/kestra/commit/dc8576afe))
+- Make dashboard tables the right color ([6f7bb80c6](https://github.com/kestra-io/kestra/commit/6f7bb80c6))
+- Use the udpated labelsFromQuery in labels ([ec967a57f](https://github.com/kestra-io/kestra/commit/ec967a57f))
+- **ci:** Workflow test correct previous job status usage ([9ba27b9bd](https://github.com/kestra-io/kestra/commit/9ba27b9bd))
+- **ci:** Disabled previous generate translations CI ([5dcd27c06](https://github.com/kestra-io/kestra/commit/5dcd27c06))
+- **ci:** Missing checkout in release step ([09ff9d405](https://github.com/kestra-io/kestra/commit/09ff9d405))
+- **ci:** Removed useless name in action files ([4986d68f5](https://github.com/kestra-io/kestra/commit/4986d68f5))
+- **ci:** Pass correctly secret + cleanup ([945564366](https://github.com/kestra-io/kestra/commit/945564366))
+- **cicd:** Add npm install on vulnerabilities check ([9790f0237](https://github.com/kestra-io/kestra/commit/9790f0237))
+- **ci:** Workflow test ouptputs + changes for codecov ([c3e830c2c](https://github.com/kestra-io/kestra/commit/c3e830c2c))
+- **ci:** Inputs instead of secrets ([c53239470](https://github.com/kestra-io/kestra/commit/c53239470))
+- **core:** #7227 cron schedule with timezone and backfile not triggering ([#7285](https://github.com/kestra-io/kestra/pull/7285), [#7227](https://github.com/kestra-io/kestra/issues/7227))
+- Force run docs ([#7289](https://github.com/kestra-io/kestra/pull/7289))
+- Collapsed menu colors in light mode ([0becf7433](https://github.com/kestra-io/kestra/commit/0becf7433))
+- **ui:** Match chart colors ([#7290](https://github.com/kestra-io/kestra/pull/7290))
+- **makefile:** Build plugin now build main branch too ([#7297](https://github.com/kestra-io/kestra/pull/7297))
+- **core:** Flacky trigger with backfile test ([#7295](https://github.com/kestra-io/kestra/pull/7295))
+- **core:** Http client was not using deprecated setter ([25370d10b](https://github.com/kestra-io/kestra/commit/25370d10b))
+- **core:** Do not validate subflow if namespace or id is pebble ([#7294](https://github.com/kestra-io/kestra/pull/7294))
+- **h2:** Remove indenting in sql file ([#7306](https://github.com/kestra-io/kestra/pull/7306))
+- **core:** Add request.yaml file back ([#7308](https://github.com/kestra-io/kestra/pull/7308))
+- **core:** Possible NPE when an execution has no labels ([7dbf86d54](https://github.com/kestra-io/kestra/commit/7dbf86d54))
+- **cicd:** Npm install in the wrong folder for vulnerabilities checks ([7bf42cb1c](https://github.com/kestra-io/kestra/commit/7bf42cb1c))
+- Add proper ellipsis to sidemenu ([#7361](https://github.com/kestra-io/kestra/pull/7361))
+- Trim bookmarks better ([#7359](https://github.com/kestra-io/kestra/pull/7359))
+- **ui:** Make sure bulk selection is taking into account only selected items ([#7362](https://github.com/kestra-io/kestra/pull/7362))
+- Make menu hierarchy get closer to the original designs ([#7102](https://github.com/kestra-io/kestra/pull/7102))
+- **core:** Render list ([b45a44bd3](https://github.com/kestra-io/kestra/commit/b45a44bd3))
+- **jdbc:** Delete the executor state at the correct stage ([1d65fd96b](https://github.com/kestra-io/kestra/commit/1d65fd96b))
+- **ui:** Refresh dashboard list ([#7370](https://github.com/kestra-io/kestra/pull/7370))
+- **core:** Handle http request with no content type ([239fb6a68](https://github.com/kestra-io/kestra/commit/239fb6a68))
+- **cicd:** Add mariadb plugins on docker image ([5b29a0d07](https://github.com/kestra-io/kestra/commit/5b29a0d07))
+- **scheduler:** Delete trigger when flow is not found ([#7366](https://github.com/kestra-io/kestra/pull/7366))
+- **cli:** Disable by default OTEL metrics ([def8fa3ff](https://github.com/kestra-io/kestra/commit/def8fa3ff))
+- Changing language should work with providers too ([b8d0ae3ec](https://github.com/kestra-io/kestra/commit/b8d0ae3ec))
+- **ui:** Fix slack button on error toast ([ad651cdc5](https://github.com/kestra-io/kestra/commit/ad651cdc5))
+- **ui:** Properly handle the operation labels in filter component ([#7399](https://github.com/kestra-io/kestra/pull/7399))
+- **core:** Taskrun list can be null ([ddfed2e65](https://github.com/kestra-io/kestra/commit/ddfed2e65))
+- **ui:** Correct english translations ([#7401](https://github.com/kestra-io/kestra/pull/7401))
+- **core:** ForEachItem inside an If task ([d9d2f8697](https://github.com/kestra-io/kestra/commit/d9d2f8697))
+- **test:** Attempt at making the test not flakky ([#7400](https://github.com/kestra-io/kestra/pull/7400))
+- Enable rendering of commands properties inside CommandsWrapper ([#7381](https://github.com/kestra-io/kestra/pull/7381))
+- Restore red dot when there is news ([fbd893434](https://github.com/kestra-io/kestra/commit/fbd893434))
+- **tests:** Wider maxDuration for retry-failed-flow-duration.yml ([d55ce16f5](https://github.com/kestra-io/kestra/commit/d55ce16f5))
+- **ui:** Better duration consistency on Gantt chart ([4a55485cd](https://github.com/kestra-io/kestra/commit/4a55485cd))
+- **tests:** Logs are asynchronously inserted so we wait for them to be fully in ([13cb0fb96](https://github.com/kestra-io/kestra/commit/13cb0fb96))
+- **ui:** Improve modifying inputs from no code editor ([#7440](https://github.com/kestra-io/kestra/pull/7440))
+- **core:** Provide tenantId when looking for subflow ([#7442](https://github.com/kestra-io/kestra/pull/7442))
+- **core:** Move back to the old worker thread pool because it was restricting it to 1 thread ([372327581](https://github.com/kestra-io/kestra/commit/372327581))
+- **core:** Remove props with default from `required` in json schema to avoid validation errors ([15b85ac95](https://github.com/kestra-io/kestra/commit/15b85ac95))
+- **core:** Render `delete` property at the beginning in Docker task runner ([16e3830c9](https://github.com/kestra-io/kestra/commit/16e3830c9))
+- **tests:** Increase timeout on JdbcServiceLivenessCoordinatorTest.taskResubmitSkipExecution ([cebe8f354](https://github.com/kestra-io/kestra/commit/cebe8f354))
+- **cicd:** Update concurrency key ([666f8a7ad](https://github.com/kestra-io/kestra/commit/666f8a7ad))
+- **core:** Http proxy was not passed to configuration ([a53395ab3](https://github.com/kestra-io/kestra/commit/a53395ab3))
+- **ci:** QEMU issue ([ce15ca1ca](https://github.com/kestra-io/kestra/commit/ce15ca1ca))
+- **webserver:** Allow special chars in label key ([#7419](https://github.com/kestra-io/kestra/pull/7419))
+- **ui:** Properly cast value to boolean ([#7455](https://github.com/kestra-io/kestra/pull/7455))
+- **ui:** Improve handling of main filter labels on page load ([#7456](https://github.com/kestra-io/kestra/pull/7456))
+- **ui:** Fix the light theme contrast for editor. ([#7438](https://github.com/kestra-io/kestra/pull/7438))
+- **core:** If subflow is disabled, raise an error ([#7490](https://github.com/kestra-io/kestra/pull/7490))
+- Render before command with options in CommandsWrapper ([#7496](https://github.com/kestra-io/kestra/pull/7496))
+- **tasks:** Remove useless format metrics on return ([#7486](https://github.com/kestra-io/kestra/pull/7486))
+- **core:** Require condition in Flow trigger ([#7494](https://github.com/kestra-io/kestra/pull/7494))
+- **ui:** Make flow metrics behave as expected ([#7502](https://github.com/kestra-io/kestra/pull/7502))
+- **ui:** Properly filter out log levels ([#7503](https://github.com/kestra-io/kestra/pull/7503))
+- **core:** Add package-info.java to dashboard package ([df92491e5](https://github.com/kestra-io/kestra/commit/df92491e5))
+- **core:** Add package-info.java to script + handle subgroups properly ([ac2643c10](https://github.com/kestra-io/kestra/commit/ac2643c10))
+- **core:** Try to log message for unhandled realtime trigger exception ([a115eb537](https://github.com/kestra-io/kestra/commit/a115eb537))
+- **core:** Move package-info.java to proper dashboard packages ([16284e5b9](https://github.com/kestra-io/kestra/commit/16284e5b9))
+- **core:** Rename dashboards subgroups ([9ec4d9282](https://github.com/kestra-io/kestra/commit/9ec4d9282))
+- **core:** Typo in PluginScanner ([25723b1ac](https://github.com/kestra-io/kestra/commit/25723b1ac))
+- **core:** Camel to snake-case for app-blocks in RegisteredPlugin ([c8c0c4e63](https://github.com/kestra-io/kestra/commit/c8c0c4e63))
+- **core:** Missing content type on http client ([9fce6cfe6](https://github.com/kestra-io/kestra/commit/9fce6cfe6))
+- **jdbc:** Be resilient to DataException ([cf10269f2](https://github.com/kestra-io/kestra/commit/cf10269f2))
+- **core:** Content type encoding should not be mandatory ([4500c976d](https://github.com/kestra-io/kestra/commit/4500c976d))
+- **core:** #172 add reactor into classloader blacklist ([#172](https://github.com/kestra-io/kestra/issues/172))
+- **ui:** Amend filtering of logs ([#7535](https://github.com/kestra-io/kestra/pull/7535))
+- **core:** Handle space in HTTP request URI ([a2c89e508](https://github.com/kestra-io/kestra/commit/a2c89e508))
+- **core:** Subflow using the old task name never ends ([38b8190be](https://github.com/kestra-io/kestra/commit/38b8190be))
+- **ui:** Amend label filter encoding after values change ([#7536](https://github.com/kestra-io/kestra/pull/7536))
+- **ui:** Plugins TOC is now handling every type of plugins ([48b117b35](https://github.com/kestra-io/kestra/commit/48b117b35))
+- **ui:** Styling enhancements for plugin doc ([ff4f7abb0](https://github.com/kestra-io/kestra/commit/ff4f7abb0))
+- **ui:** Preselect filter comparator option ([#7518](https://github.com/kestra-io/kestra/pull/7518))
+- **ui:** Improve coloring for task object tooltips in no code editor ([#7515](https://github.com/kestra-io/kestra/pull/7515))
+- Refactor PluginSearchCommand ([8d2af87db](https://github.com/kestra-io/kestra/commit/8d2af87db))
+- **ui:** Make flow deletion work as expected ([#7579](https://github.com/kestra-io/kestra/pull/7579))
+- **ui:** Amend inconsistencies inside the product tour ([#7582](https://github.com/kestra-io/kestra/pull/7582))
+- **core:** Log can have no executionId ([fc7ef1ca3](https://github.com/kestra-io/kestra/commit/fc7ef1ca3))
+- **core:** Properly render list properties ([7fbe43322](https://github.com/kestra-io/kestra/commit/7fbe43322))
+- **ui:** Make sure adding labels on flow run dialog is possible ([#7587](https://github.com/kestra-io/kestra/pull/7587))
+- **ui:** LabelInput.vue was causing UI freeze ([a996347de](https://github.com/kestra-io/kestra/commit/a996347de))
+- Ci for translations ([#7602](https://github.com/kestra-io/kestra/pull/7602))
+- **translations:** Fix translation key detection by comparing against last modifying commit ([#7604](https://github.com/kestra-io/kestra/pull/7604))
+- Only re-translate if the key is not already in the target dict ([#7608](https://github.com/kestra-io/kestra/pull/7608))
+- Clean up translations script ([81635ddc8](https://github.com/kestra-io/kestra/commit/81635ddc8))
+- Improve some wording ([ae75ea06d](https://github.com/kestra-io/kestra/commit/ae75ea06d))
+- **translations:** Allow retranslating modified keys when needed ([020d674d8](https://github.com/kestra-io/kestra/commit/020d674d8))
+- Turn CI flag to a dropdown ([d04764814](https://github.com/kestra-io/kestra/commit/d04764814))
+- Improve translation prompt ([3804bdc7f](https://github.com/kestra-io/kestra/commit/3804bdc7f))
+- Make sure nocode edits the right task from the topology ([3dc8e98ed](https://github.com/kestra-io/kestra/commit/3dc8e98ed))
+- **ui:** Replace alert blocks upon markdown rendering to display them properly ([9b4f3148f](https://github.com/kestra-io/kestra/commit/9b4f3148f))
+- Confusing trace log ([c8207b870](https://github.com/kestra-io/kestra/commit/c8207b870))
+- **ui:** Executions naviation based on start Date. ([#7626](https://github.com/kestra-io/kestra/pull/7626))
+- **core:** No longer lowercasing PluginClassIdentifier to have proper validation upon Plugin deserialization ([17e54134c](https://github.com/kestra-io/kestra/commit/17e54134c))
+- **ui:** Additional check for text label of filters section ([446a034d6](https://github.com/kestra-io/kestra/commit/446a034d6))
+- **ui:** Improve check for text label of filters section ([036a7cf4f](https://github.com/kestra-io/kestra/commit/036a7cf4f))
+- **ui:** Use watch with ref instead of accessing the value ([5f21eb579](https://github.com/kestra-io/kestra/commit/5f21eb579))
+- **ui:** Allow sidebar theme toggle to update the editor theme ([#7648](https://github.com/kestra-io/kestra/pull/7648))
+- **ci:** Fix vulnerability check workflow ([8bd3c2fef](https://github.com/kestra-io/kestra/commit/8bd3c2fef))
+- **ui:** Make sure adding labels on flow run dialog is possible ([#7652](https://github.com/kestra-io/kestra/pull/7652))
+- **cicd:** Missing acls for test reports ([d2bf56fec](https://github.com/kestra-io/kestra/commit/d2bf56fec))
+- **core:** Validation error when timeWindow.type is null ([1eb9adf30](https://github.com/kestra-io/kestra/commit/1eb9adf30))
+- **core:** MultipleCondition documentation ([12180457e](https://github.com/kestra-io/kestra/commit/12180457e))
+- **core:** Avoid duplicates in plugins subgroups + properly retrieve subgroup title ([ef65623b1](https://github.com/kestra-io/kestra/commit/ef65623b1))
+- **cli:** Fix regression on CLI plugin doc cmd ([e200bbdb6](https://github.com/kestra-io/kestra/commit/e200bbdb6))
+- **core:** Stop Docker runner gracefully ([8f9fc5fe4](https://github.com/kestra-io/kestra/commit/8f9fc5fe4))
+- **ui:** Prevent context docs open on editor custom blueprints click ([#7716](https://github.com/kestra-io/kestra/pull/7716))
+- **runner-memory:** Delete MemorySchedulerTriggerState back due to cherry-pick ([593558dd2](https://github.com/kestra-io/kestra/commit/593558dd2))
+- **ui:** Improved fetch of type for pluginDoc and avoid removing doc if map has "type" as property but without doc (like ENUM value) ([#7727](https://github.com/kestra-io/kestra/pull/7727))
+- **demo:** On pages stop showing the docs without a button ([07e4598fa](https://github.com/kestra-io/kestra/commit/07e4598fa))
+- Repair collapsed menu submenus ([467861652](https://github.com/kestra-io/kestra/commit/467861652))
+- **flow editor:** Enhance behavior when switching file tabs ([#7722](https://github.com/kestra-io/kestra/pull/7722))
+- **tests:** Reject promise with 404 instead of empty resolve if non-mocked store call in flowAutoCompletionProvider.spec.ts ([166262209](https://github.com/kestra-io/kestra/commit/166262209))
+- **jdbc:** Resubmit worker job to the good worker group ([7696d41d5](https://github.com/kestra-io/kestra/commit/7696d41d5))
+- **ci:** Generate_translations.py is now deleting keys that are no longer in en translation to avoid ghost translations ([440a94290](https://github.com/kestra-io/kestra/commit/440a94290))
+- **core:** ThresholdFilter is now stricly lower" ([4276a0afd](https://github.com/kestra-io/kestra/commit/4276a0afd))
+- **core:** Failing schedule test ([#7783](https://github.com/kestra-io/kestra/pull/7783))
+- **cli:** Fix double shutdown warn messages ([d2d0726f7](https://github.com/kestra-io/kestra/commit/d2d0726f7))
+- **core:** Flaky test ExitTest.shouldExitAndKillTheExecution() ([0870d8ebd](https://github.com/kestra-io/kestra/commit/0870d8ebd))
+- **jdbc:** Flaky tests JdbcServiceLivenessCoordinatorTest ([5ffeee532](https://github.com/kestra-io/kestra/commit/5ffeee532))
+- **core:** Wait for service-manager-task thread to be stopped ([01036c829](https://github.com/kestra-io/kestra/commit/01036c829))
+- **tests:** Increase seconds diff between dates ([#7785](https://github.com/kestra-io/kestra/pull/7785))
+- **core:** #7740 http configuration bearer token may change to basic because of allowFailed ([#7788](https://github.com/kestra-io/kestra/pull/7788), [#7740](https://github.com/kestra-io/kestra/issues/7740))
+- **jdbc:** Return correct total when paginating custom dashboard chart ([#7790](https://github.com/kestra-io/kestra/pull/7790))
+- **webserver:** Add endpoint for inherited secrets ([9b5b2b981](https://github.com/kestra-io/kestra/commit/9b5b2b981))
+- **ui:** Make switch view buttons from dashboard editor the same as flow editor ones ([82a346b2c](https://github.com/kestra-io/kestra/commit/82a346b2c))
+- **ui:** Remove errors from dashboard validation if it's fixed ([4a1282768](https://github.com/kestra-io/kestra/commit/4a1282768))
+- **core:** Fix properly map MavenPluginRepositoryConfig ([1cb323b7a](https://github.com/kestra-io/kestra/commit/1cb323b7a))
+- **docs:** 2025 get started video ([977fe222a](https://github.com/kestra-io/kestra/commit/977fe222a))
+- **core:** AllowedNamespace is already called in the KvStoreService ([e2da2dfeb](https://github.com/kestra-io/kestra/commit/e2da2dfeb))
+- **core:** Missing afterExecution in FlowForExecution ([141968000](https://github.com/kestra-io/kestra/commit/141968000))
+- **deps:** Move OTLP metrics lib to CLI to avoid warning in tests ([acebfef0d](https://github.com/kestra-io/kestra/commit/acebfef0d))
+- **core:** Avoid calling Worker post construct method twice ([c9baaf856](https://github.com/kestra-io/kestra/commit/c9baaf856))
+- **ui:** Display back core property if not in a task ([64e5b8004](https://github.com/kestra-io/kestra/commit/64e5b8004))
+- **docs:** Add parallel example ([ff504afd8](https://github.com/kestra-io/kestra/commit/ff504afd8))
+- Remove labels from an execution ([#7256](https://github.com/kestra-io/kestra/pull/7256))
+- **docs:** Schedule example ([ebec8c212](https://github.com/kestra-io/kestra/commit/ebec8c212))
+- **docs:** Fail examples ([379199e18](https://github.com/kestra-io/kestra/commit/379199e18))
+- **docs:** Typos ([02336ed39](https://github.com/kestra-io/kestra/commit/02336ed39))
+- **ui:** Use container queries for dashboard ([#7889](https://github.com/kestra-io/kestra/pull/7889))
+- **core:** Avoid ClassCastException when parsing flow inputs ([#7882](https://github.com/kestra-io/kestra/pull/7882))
+- **ui:** Amend displaying large amount of logs ([#7923](https://github.com/kestra-io/kestra/pull/7923))
+- Disable micronaut otel by default ([8076fcc99](https://github.com/kestra-io/kestra/commit/8076fcc99))
+- **cli:** Return exit 0 in CLI plugins cmd ([3566c4d36](https://github.com/kestra-io/kestra/commit/3566c4d36))
+- OpenTelemetry should be optional ([0ee9abb37](https://github.com/kestra-io/kestra/commit/0ee9abb37))
+- ***:** Improve log timestamp precision + allow to override timestamp… ([#7847](https://github.com/kestra-io/kestra/pull/7847))
+- **ui:** Amend dependabot errors with parsing of package-lock.json file ([#7941](https://github.com/kestra-io/kestra/pull/7941))
+- **core:** Possible NPE if no manifest ([8cba4dab6](https://github.com/kestra-io/kestra/commit/8cba4dab6))
+- **ui:** Prevent filter text prefix to show up when searching locally ([#7947](https://github.com/kestra-io/kestra/pull/7947))
+- **core:** Triggers don't have an execution ID already ([0579e23a2](https://github.com/kestra-io/kestra/commit/0579e23a2))
+- **core-ee:** NPE when execution labels are null ([#7950](https://github.com/kestra-io/kestra/pull/7950))
+- Only run posthog in prod mode ([#7952](https://github.com/kestra-io/kestra/pull/7952))
+- **core:** Add metric Publish task doc & icon ([481138e43](https://github.com/kestra-io/kestra/commit/481138e43))
+- Update ui-libs ([cca7ed0bf](https://github.com/kestra-io/kestra/commit/cca7ed0bf))
+- **ui:** Filter tests were not up-to-date ([f3419084f](https://github.com/kestra-io/kestra/commit/f3419084f))
+- **cicd:** Display ui unit test status ([df1bbcfb7](https://github.com/kestra-io/kestra/commit/df1bbcfb7))
+- **ui:** Change plugin doc properly upon switching plugin type ([773a6e909](https://github.com/kestra-io/kestra/commit/773a6e909))
+- **core:** Working dir interface contract by putting back putFile(path, content) ([#7980](https://github.com/kestra-io/kestra/pull/7980))
+- **ui:** Include parameters into request for plugin schema fetching ([#8002](https://github.com/kestra-io/kestra/pull/8002))
+- **core:** Amend server start announcements ([49a29c4bf](https://github.com/kestra-io/kestra/commit/49a29c4bf))
+- **build:** Gradle space-assignment deprecation ([a1abd28a3](https://github.com/kestra-io/kestra/commit/a1abd28a3))
+- **core:** Race in the FlowListener ([19894dbcd](https://github.com/kestra-io/kestra/commit/19894dbcd))
+- **core:** Race while initializing trigger + possible duplicate update ([742169344](https://github.com/kestra-io/kestra/commit/742169344))
+- Remove unwanted change in Curl ([3244b1c29](https://github.com/kestra-io/kestra/commit/3244b1c29))
+- **ui:** Amend task source tabs colors ([#8010](https://github.com/kestra-io/kestra/pull/8010))
+- **platform:** Move slf4j api to enforce platform to fix it's version in test ([#8007](https://github.com/kestra-io/kestra/pull/8007))
+- **core:** Handling for trailing slash in the KESTRA_URL configuration ([#6373](https://github.com/kestra-io/kestra/pull/6373))
+- **ui:** Prevent function parameters autocompletion from deleting parenthesis ([74455ad99](https://github.com/kestra-io/kestra/commit/74455ad99))
+- **ui:** Handle properly layout of global Secrets when there is a secret manager ([edbf14c1b](https://github.com/kestra-io/kestra/commit/edbf14c1b))
+- **core:** Ensure defaults can be injected in flows ([#3206](https://github.com/kestra-io/kestra/pull/3206))
+- **ui:** Allow multi label filtering ([#8022](https://github.com/kestra-io/kestra/pull/8022))
+- **ui:** Fail-safe secrets API calls ([c64c2c710](https://github.com/kestra-io/kestra/commit/c64c2c710))
+- **ui:** Amend operator value of labels inside the filter ([#8028](https://github.com/kestra-io/kestra/pull/8028))
+- **ui:** Fail-safe secrets API calls on global secrets view ([28d1f005a](https://github.com/kestra-io/kestra/commit/28d1f005a))
+- **core:** Fix NPE when closing standalone runner ([6c9dc8fba](https://github.com/kestra-io/kestra/commit/6c9dc8fba))
+- **ui:** Make sure global secret view iterates over all secrets ([75e763550](https://github.com/kestra-io/kestra/commit/75e763550))
+- **cli:** Make worker args available through static KestraContext ([dea66ca25](https://github.com/kestra-io/kestra/commit/dea66ca25))
+- **core:** Flatten map should not throw an exception ([4c93a2b0e](https://github.com/kestra-io/kestra/commit/4c93a2b0e))
+- **webserver:** First eval without masking secret function to error in case of missing secret ([8f4ce5fc1](https://github.com/kestra-io/kestra/commit/8f4ce5fc1))
+- **ui:** Properly detect yaml to inject json schema into MonacoEditor ([8be17827c](https://github.com/kestra-io/kestra/commit/8be17827c))
+- **core:** HttpClient log the URL even if it's a secret ([54aa93570](https://github.com/kestra-io/kestra/commit/54aa93570))
+- **core:** Properly fix the issue with MapUtils.flattenToNestedMap ([b8e8333f6](https://github.com/kestra-io/kestra/commit/b8e8333f6))
+- **kafka runner:** #2709 filter child forEach tasks before merging th… ([#8095](https://github.com/kestra-io/kestra/pull/8095), [#2709](https://github.com/kestra-io/kestra/issues/2709))
+- **core:** Avoid flow validation error on plugin alias duplicates ([8ebc3fbba](https://github.com/kestra-io/kestra/commit/8ebc3fbba))
+- Doc and deprecated field was not showing for dynamic non-string properties ([#8006](https://github.com/kestra-io/kestra/pull/8006))
+- **core:** Require condition in Flow trigger " ([#7494](https://github.com/kestra-io/kestra/pull/7494))
+- **core:** Compilation issue ([380e329e9](https://github.com/kestra-io/kestra/commit/380e329e9))
+- **core:** Namespace service now properly detects namespaces with flows inside ([a09319800](https://github.com/kestra-io/kestra/commit/a09319800))
+- **webserver:** Handle out-of-bounds (>) namespaces fetch ([224026c39](https://github.com/kestra-io/kestra/commit/224026c39))
+- **ui:** Add routeContext where it was missing ([143ebc061](https://github.com/kestra-io/kestra/commit/143ebc061))
+- **ui:** Repair tenant translation ([b3799cc03](https://github.com/kestra-io/kestra/commit/b3799cc03))
+- **ui:** Global secret page design ([54eccac63](https://github.com/kestra-io/kestra/commit/54eccac63))
+- **ui:** Search bars are properly working in secrets & KV pages ([4e7c6e87b](https://github.com/kestra-io/kestra/commit/4e7c6e87b))
+- **core:** Allow dash in plugin version qualifier ([95b1f8dfc](https://github.com/kestra-io/kestra/commit/95b1f8dfc))
+- **cli:** Properly register plugins uninstall cmd ([91bf3207f](https://github.com/kestra-io/kestra/commit/91bf3207f))
+- **core:** Add missing docker plugin subgroup icon ([1613dee76](https://github.com/kestra-io/kestra/commit/1613dee76))
+- Task array needed better typings ([#8158](https://github.com/kestra-io/kestra/pull/8158))
+- Make flowWarnings show to unlock saving ([#8157](https://github.com/kestra-io/kestra/pull/8157))
+
+### 💅 Refactors
+
+- Introduce render in commands wrapper for property string ([#7430](https://github.com/kestra-io/kestra/pull/7430))
+- Avoid en.json warning when building ([df6d33931](https://github.com/kestra-io/kestra/commit/df6d33931))
+- Remove rendering from Docker ([#7439](https://github.com/kestra-io/kestra/pull/7439))
+- Return only command when no interpreter and no beforeCommands ([#7452](https://github.com/kestra-io/kestra/pull/7452))
+- **ui:** Remove obsolete `chartjs-chart-treemap` library ([#7529](https://github.com/kestra-io/kestra/pull/7529))
+- Update http client and fix tests ([be04c168f](https://github.com/kestra-io/kestra/commit/be04c168f))
+- **ui:** Remove the obsolete console statement ([#7887](https://github.com/kestra-io/kestra/pull/7887))
+- Move flow editor logic into flow store ([#7968](https://github.com/kestra-io/kestra/pull/7968))
+
+### 📖 Documentation
+
+- **core:** Better documentation on docker tasks ([f4b78755a](https://github.com/kestra-io/kestra/commit/f4b78755a))
+- Debug expression ([#7514](https://github.com/kestra-io/kestra/pull/7514))
+- Fix typo in storage reverse task title ([#7667](https://github.com/kestra-io/kestra/pull/7667))
+- Kv pebble ([#7886](https://github.com/kestra-io/kestra/pull/7886))
+
+### 📦 Build
+
+- Try and fix FE CI ([4234c76b0](https://github.com/kestra-io/kestra/commit/4234c76b0))
+- Prevent corepack crash ([3c7e26c88](https://github.com/kestra-io/kestra/commit/3c7e26c88))
+- **deps:** Bump software.amazon.awssdk:bom from 2.30.6 to 2.30.11 ([d50f631fb](https://github.com/kestra-io/kestra/commit/d50f631fb))
+- **deps:** Bump com.azure:azure-sdk-bom from 1.2.30 to 1.2.31 ([bd0e4a5f4](https://github.com/kestra-io/kestra/commit/bd0e4a5f4))
+- **deps:** Bump software.amazon.awssdk.crt:aws-crt ([f1f0d3186](https://github.com/kestra-io/kestra/commit/f1f0d3186))
+- **deps:** Bump flyingSaucerVersion from 9.11.2 to 9.11.3 ([d769b7aad](https://github.com/kestra-io/kestra/commit/d769b7aad))
+- **deps:** Bump com.gradleup.shadow from 8.3.5 to 8.3.6 ([3a0beabe4](https://github.com/kestra-io/kestra/commit/3a0beabe4))
+- **deps:** Bump org.owasp.dependencycheck from 12.0.1 to 12.0.2 ([36306495e](https://github.com/kestra-io/kestra/commit/36306495e))
+- **deps:** Bump posthog-js from 1.215.2 to 1.215.3 in /ui ([#7182](https://github.com/kestra-io/kestra/pull/7182))
+- **deps:** Bump shiki from 2.3.0 to 2.3.1 in /ui ([#7183](https://github.com/kestra-io/kestra/pull/7183))
+- **deps-dev:** Bump @shikijs/markdown-it from 2.3.0 to 2.3.1 in /ui ([#7184](https://github.com/kestra-io/kestra/pull/7184))
+- **deps:** Bump com.google.cloud:libraries-bom from 26.53.0 to 26.54.0 ([5aa73ec48](https://github.com/kestra-io/kestra/commit/5aa73ec48))
+- **deps:** Bump software.amazon.awssdk:bom from 2.30.11 to 2.30.16 ([8a3f41323](https://github.com/kestra-io/kestra/commit/8a3f41323))
+- **deps:** Bump software.amazon.awssdk.crt:aws-crt ([55bdfac7f](https://github.com/kestra-io/kestra/commit/55bdfac7f))
+- **deps:** Bump com.microsoft.playwright:playwright ([48320a89d](https://github.com/kestra-io/kestra/commit/48320a89d))
+- **deps:** Bump io.pebbletemplates:pebble from 3.2.2 to 3.2.3 ([8260dc603](https://github.com/kestra-io/kestra/commit/8260dc603))
+- **deps:** Bump io.micronaut.platform:micronaut-platform ([4c5638d95](https://github.com/kestra-io/kestra/commit/4c5638d95))
+- **deps:** Bump org.opensearch.client:opensearch-java ([90da5f7cf](https://github.com/kestra-io/kestra/commit/90da5f7cf))
+- **deps:** Bump io.micronaut.platform:micronaut-platform ([f3cff1b8c](https://github.com/kestra-io/kestra/commit/f3cff1b8c))
+- **deps:** Bump com.github.oshi:oshi-core from 6.6.6 to 6.7.0 ([66fdb58f4](https://github.com/kestra-io/kestra/commit/66fdb58f4))
+- **deps:** Bump nl.basjes.gitignore:gitignore-reader ([4b48ad597](https://github.com/kestra-io/kestra/commit/4b48ad597))
+- **deps:** Bump org.owasp.dependencycheck from 12.0.2 to 12.1.0 ([94421f141](https://github.com/kestra-io/kestra/commit/94421f141))
+- **deps:** Bump software.amazon.awssdk:bom from 2.30.16 to 2.30.31 ([e7f2ec2ae](https://github.com/kestra-io/kestra/commit/e7f2ec2ae))
+- **deps:** Bump opensearchRestVersion from 2.18.0 to 2.19.1 ([b6f91128a](https://github.com/kestra-io/kestra/commit/b6f91128a))
+- **deps:** Bump com.google.cloud:libraries-bom from 26.54.0 to 26.56.0 ([82df58d26](https://github.com/kestra-io/kestra/commit/82df58d26))
+- **deps:** Bump org.opensearch.client:opensearch-java ([ca4e6a4b3](https://github.com/kestra-io/kestra/commit/ca4e6a4b3))
+- **deps:** Bump jacksonVersion from 2.18.2 to 2.18.3 ([20b87f1c9](https://github.com/kestra-io/kestra/commit/20b87f1c9))
+- **deps:** Bump robinraju/release-downloader from 1.11 to 1.12 ([038890982](https://github.com/kestra-io/kestra/commit/038890982))
+- **deps:** Bump com.azure:azure-sdk-bom from 1.2.31 to 1.2.32 ([92418841f](https://github.com/kestra-io/kestra/commit/92418841f))
+- **deps:** Bump com.gorylenko.gradle-git-properties ([0a304ff1d](https://github.com/kestra-io/kestra/commit/0a304ff1d))
+- **deps:** Bump org.testcontainers:junit-jupiter from 1.20.5 to 1.20.6 ([5af085844](https://github.com/kestra-io/kestra/commit/5af085844))
+- **deps:** Bump org.opensearch.client:opensearch-java ([03a44c103](https://github.com/kestra-io/kestra/commit/03a44c103))
+- **deps:** Bump com.github.docker-java:docker-java from 3.4.1 to 3.4.2 ([8d7bc6fdd](https://github.com/kestra-io/kestra/commit/8d7bc6fdd))
+- **deps:** Bump org.jsoup:jsoup from 1.18.3 to 1.19.1 ([83f06f337](https://github.com/kestra-io/kestra/commit/83f06f337))
+- **deps:** Bump software.amazon.awssdk.crt:aws-crt ([5935308e4](https://github.com/kestra-io/kestra/commit/5935308e4))
+- **deps:** Bump org.testcontainers:testcontainers ([fefaa7cdb](https://github.com/kestra-io/kestra/commit/fefaa7cdb))
+- **deps:** Bump software.amazon.awssdk:bom from 2.30.31 to 2.30.36 ([66e5a7ca3](https://github.com/kestra-io/kestra/commit/66e5a7ca3))
+- **deps:** Bump io.micrometer:micrometer-core from 1.14.3 to 1.14.5 ([dea392a94](https://github.com/kestra-io/kestra/commit/dea392a94))
+- **deps:** Bump @babel/helpers from 7.26.9 to 7.26.10 in /ui ([#7841](https://github.com/kestra-io/kestra/pull/7841))
+- **deps:** Bump @babel/runtime-corejs3 from 7.26.9 to 7.26.10 in /ui ([#7840](https://github.com/kestra-io/kestra/pull/7840))
+- **deps:** Bump software.amazon.awssdk:bom from 2.30.36 to 2.31.1 ([149dcac5f](https://github.com/kestra-io/kestra/commit/149dcac5f))
+- **deps:** Bump protobufVersion from 3.25.5 to 4.30.1 ([6946c9268](https://github.com/kestra-io/kestra/commit/6946c9268))
+- **deps:** Bump software.amazon.awssdk.crt:aws-crt ([0134d5e5c](https://github.com/kestra-io/kestra/commit/0134d5e5c))
+- **deps:** Bump com.github.oshi:oshi-core from 6.7.0 to 6.7.1 ([8eb91b75e](https://github.com/kestra-io/kestra/commit/8eb91b75e))
+- **deps:** Bump dorny/test-reporter from 1 to 2 ([ab061e9a1](https://github.com/kestra-io/kestra/commit/ab061e9a1))
+- **deps:** Bump aquasecurity/trivy-action from 0.29.0 to 0.30.0 ([7f6e15ec4](https://github.com/kestra-io/kestra/commit/7f6e15ec4))
+- **deps:** Bump nl.basjes.gitignore:gitignore-reader ([3dcd3c978](https://github.com/kestra-io/kestra/commit/3dcd3c978))
+- **deps:** Bump org.jooq:jooq from 3.19.18 to 3.20.2 ([ab9ba91e5](https://github.com/kestra-io/kestra/commit/ab9ba91e5))
+- **deps:** Bump org.slf4j:slf4j-api from 2.0.16 to 2.0.17 ([f89aa8d27](https://github.com/kestra-io/kestra/commit/f89aa8d27))
+- **deps:** Bump org.aspectj:aspectjweaver from 1.9.22.1 to 1.9.23 ([5c73953c8](https://github.com/kestra-io/kestra/commit/5c73953c8))
+- **deps:** Bump pdfjs-dist from 4.10.38 to 5.0.375 in /ui ([#7942](https://github.com/kestra-io/kestra/pull/7942))
+- **deps:** Bump protobufVersion from 3.25.5 to 4.30.1" ([0ec2d8842](https://github.com/kestra-io/kestra/commit/0ec2d8842))
+- **deps:** Bump com.microsoft.playwright:playwright ([6d59630a6](https://github.com/kestra-io/kestra/commit/6d59630a6))
+- **deps:** Bump com.google.cloud:libraries-bom from 26.56.0 to 26.57.0 ([491f07296](https://github.com/kestra-io/kestra/commit/491f07296))
+- **deps:** Bump com.github.oshi:oshi-core from 6.7.1 to 6.8.0 ([37af61f41](https://github.com/kestra-io/kestra/commit/37af61f41))
+- **deps:** Bump software.amazon.awssdk:bom from 2.31.1 to 2.31.6 ([62e37f3b1](https://github.com/kestra-io/kestra/commit/62e37f3b1))
+- **deps:** Bump software.amazon.awssdk.crt:aws-crt ([5a2ac895e](https://github.com/kestra-io/kestra/commit/5a2ac895e))
+
+### 🏡 Chore
+
+- **ci:** Update release workflows ([0b82b25a4](https://github.com/kestra-io/kestra/commit/0b82b25a4))
+- Update "cluster" into "instance" in side menu ([#6996](https://github.com/kestra-io/kestra/pull/6996))
+- **ui:** Move apps link in left menu just below the flows ([#7063](https://github.com/kestra-io/kestra/pull/7063))
+- **ui:** Properly check the existence of fields inside schema ([cd822bd34](https://github.com/kestra-io/kestra/commit/cd822bd34))
+- Update palette ([7a37a950b](https://github.com/kestra-io/kestra/commit/7a37a950b))
+- **translations:** Auto generate values for languages other than english ([dee76c038](https://github.com/kestra-io/kestra/commit/dee76c038))
+- **core:** Fix various compilation warnings ([625135959](https://github.com/kestra-io/kestra/commit/625135959))
+- Add a test for firefox weird wrap ([97d12f9bc](https://github.com/kestra-io/kestra/commit/97d12f9bc))
+- **ui:** Properly pass a prop related to saved searches ([594d00516](https://github.com/kestra-io/kestra/commit/594d00516))
+- **core:** Small perf improvements to MapUtils ([5a4620439](https://github.com/kestra-io/kestra/commit/5a4620439))
+- **ui:** Show each plugin deprecation warning in new line ([#6839](https://github.com/kestra-io/kestra/pull/6839))
+- **translations:** Auto generate values for languages other than english ([52159ee64](https://github.com/kestra-io/kestra/commit/52159ee64))
+- **ui:** Amend color of the input length counter ([#6990](https://github.com/kestra-io/kestra/pull/6990))
+- **ui:** Enable command palette for monaco editor ([#6944](https://github.com/kestra-io/kestra/pull/6944))
+- **translations:** Auto generate values for languages other than english ([fff8d630c](https://github.com/kestra-io/kestra/commit/fff8d630c))
+- **translations:** Auto generate values for languages other than english ([6ba71712a](https://github.com/kestra-io/kestra/commit/6ba71712a))
+- **ui:** Add skeleton loaders to dashboard cards ([#6602](https://github.com/kestra-io/kestra/pull/6602))
+- Add utility script to check for plugin artifacts ([42ad09d79](https://github.com/kestra-io/kestra/commit/42ad09d79))
+- **translations:** Auto generate values for languages other than english ([a9042fb27](https://github.com/kestra-io/kestra/commit/a9042fb27))
+- **ui:** Improve the example for not condition ([#6820](https://github.com/kestra-io/kestra/pull/6820))
+- **ui:** Update the visual of no data component ([#7179](https://github.com/kestra-io/kestra/pull/7179))
+- **ui:** Improve the states options list inside filter values ([#7176](https://github.com/kestra-io/kestra/pull/7176))
+- **translations:** Auto generate values for languages other than english ([86f3acace](https://github.com/kestra-io/kestra/commit/86f3acace))
+- **ui:** Rename advanced properties to other in no code ([#7189](https://github.com/kestra-io/kestra/pull/7189))
+- **translations:** Auto generate values for languages other than english ([e4973c331](https://github.com/kestra-io/kestra/commit/e4973c331))
+- **ui:** Rename advanced properties to other in no code ([#7190](https://github.com/kestra-io/kestra/pull/7190))
+- **translations:** Auto generate values for languages other than english ([cb7ed73be](https://github.com/kestra-io/kestra/commit/cb7ed73be))
+- **ui:** Remove the option to change editor theme separately ([#7192](https://github.com/kestra-io/kestra/pull/7192))
+- **translations:** Remove extra keys from translation files ([#7193](https://github.com/kestra-io/kestra/pull/7193))
+- **ui:** Consolidate markdown files ([#7197](https://github.com/kestra-io/kestra/pull/7197))
+- **ui:** Replace the visual for no tabs opened on namespace editor ([#7204](https://github.com/kestra-io/kestra/pull/7204))
+- **ui:** Re-order the list of optional columns ([#7213](https://github.com/kestra-io/kestra/pull/7213))
+- **ui:** Amended global pagination coloring ([#7201](https://github.com/kestra-io/kestra/pull/7201))
+- **ui:** Generate random flow ID using combination of animal names and numbers ([#7223](https://github.com/kestra-io/kestra/pull/7223))
+- **ui:** Only show warning on bulk execution deletion if nonTerminated is true ([#7211](https://github.com/kestra-io/kestra/pull/7211))
+- **ui:** Show executions per namespace only if there are 2 or more items for chart ([#7216](https://github.com/kestra-io/kestra/pull/7216))
+- **translations:** Auto generate values for languages other than english ([440faa7cd](https://github.com/kestra-io/kestra/commit/440faa7cd))
+- **ui:** Initial work on filter persistency ([#7234](https://github.com/kestra-io/kestra/pull/7234))
+- **ui:** Check for missing property on update metadata ([e335b76b3](https://github.com/kestra-io/kestra/commit/e335b76b3))
+- Update theme colors ([c31609a12](https://github.com/kestra-io/kestra/commit/c31609a12))
+- **ui:** Align chart duration label with switch toggle ([#7259](https://github.com/kestra-io/kestra/pull/7259))
+- **ui:** Align chart duration label with switch toggle ([#7258](https://github.com/kestra-io/kestra/pull/7258))
+- **ui:** Tweak the video container ratio in the docs sidebar ([#7260](https://github.com/kestra-io/kestra/pull/7260))
+- **translations:** Auto generate values for languages other than english ([e0f4ab735](https://github.com/kestra-io/kestra/commit/e0f4ab735))
+- **ui:** Disable saving flow actions if there are errors ([#7278](https://github.com/kestra-io/kestra/pull/7278))
+- **ui:** Improve flow description coloring ([#7282](https://github.com/kestra-io/kestra/pull/7282))
+- **ui:** Make action columns always visible on executions and flows ([#7291](https://github.com/kestra-io/kestra/pull/7291))
+- **core:** Rename fileEmpty Pebble function to isFileEmpty ([8de839f32](https://github.com/kestra-io/kestra/commit/8de839f32))
+- **core:** Refactor file related Pebble function to share code ([f599f2575](https://github.com/kestra-io/kestra/commit/f599f2575))
+- Remove some compilation warnings ([9505c48e5](https://github.com/kestra-io/kestra/commit/9505c48e5))
+- **ui:** Improve styling of main filter tags ([#7305](https://github.com/kestra-io/kestra/pull/7305))
+- **ui:** Introduce filters bar to flow triggers page ([#7292](https://github.com/kestra-io/kestra/pull/7292))
+- **ui:** Improve the doughnut chart legend ([#7321](https://github.com/kestra-io/kestra/pull/7321))
+- **translations:** Amend theme key ([#7356](https://github.com/kestra-io/kestra/pull/7356))
+- **ui:** Add shadows to main charts ([#7314](https://github.com/kestra-io/kestra/pull/7314))
+- **ui:** Add validation messages for custom dashboard crud actions ([#7367](https://github.com/kestra-io/kestra/pull/7367))
+- **ui:** Add link to filtered triggers page from backfill dialog ([#7380](https://github.com/kestra-io/kestra/pull/7380))
+- **ui:** Include autocompletion shortcut in the preview list ([#7384](https://github.com/kestra-io/kestra/pull/7384))
+- **ui:** Improve breadcrumbs on namespace view ([#7386](https://github.com/kestra-io/kestra/pull/7386))
+- **ui:** Improve the labels behavior ([#7397](https://github.com/kestra-io/kestra/pull/7397))
+- **ui:** Improve colors of filter dropdown selector ([#7403](https://github.com/kestra-io/kestra/pull/7403))
+- **ui:** Vertically center all elements in table rows ([#7372](https://github.com/kestra-io/kestra/pull/7372))
+- **ui:** Make import flows button be a secondary one, styling-wise ([#7405](https://github.com/kestra-io/kestra/pull/7405))
+- **ui:** Improve execution outputs section ([#7377](https://github.com/kestra-io/kestra/pull/7377))
+- **ui:** Improve filter parameters decoding for absolute date ([#7409](https://github.com/kestra-io/kestra/pull/7409))
+- **ui:** Improved Logs empty page ([#7415](https://github.com/kestra-io/kestra/pull/7415))
+- **ui:** Amend namespace flow creation label ([#7443](https://github.com/kestra-io/kestra/pull/7443))
+- **ui:** Add missing translations ([#7444](https://github.com/kestra-io/kestra/pull/7444))
+- **ui:** Add arrows to namespace listing ([#7448](https://github.com/kestra-io/kestra/pull/7448))
+- **ui:** Disable click on search button if filtering is automatic ([#7454](https://github.com/kestra-io/kestra/pull/7454))
+- **ui:** Remove obsolete props ([#7487](https://github.com/kestra-io/kestra/pull/7487))
+- **ui:** Improve styling of editor file tree ([#7420](https://github.com/kestra-io/kestra/pull/7420))
+- **translations:** Add missing key/value pairs ([#7492](https://github.com/kestra-io/kestra/pull/7492))
+- **ui:** Amend margins of EE locked pages ([#7446](https://github.com/kestra-io/kestra/pull/7446))
+- **ui:** Simplify query search with spaces inside ([#7404](https://github.com/kestra-io/kestra/pull/7404))
+- **ui:** Improve scope type filters ([#7504](https://github.com/kestra-io/kestra/pull/7504))
+- **ui:** Add translation key/value pairs ([#7509](https://github.com/kestra-io/kestra/pull/7509))
+- **ui:** Improve the scope of translations ([#7505](https://github.com/kestra-io/kestra/pull/7505))
+- **ui:** Restore automatic scroll to bottom on logs ([#7365](https://github.com/kestra-io/kestra/pull/7365))
+- **ui:** Prevent sending random strings as child filter values ([#7526](https://github.com/kestra-io/kestra/pull/7526))
+- **ui:** Purge empty labels on execution ([#7527](https://github.com/kestra-io/kestra/pull/7527))
+- **ui:** Use system namespace label from configs ([cf635058c](https://github.com/kestra-io/kestra/commit/cf635058c))
+- **ui:** Prevent system labels to be shown in set labels dialog ([#7539](https://github.com/kestra-io/kestra/pull/7539))
+- **core:** Move run context property validation to the run context ([8a26fdd83](https://github.com/kestra-io/kestra/commit/8a26fdd83))
+- Add wiremock and update tests ([04c4916ac](https://github.com/kestra-io/kestra/commit/04c4916ac))
+- **ui:** Respect default execution tab settings field when opening single execution ([#7576](https://github.com/kestra-io/kestra/pull/7576))
+- **ui:** Remove background and check mark from selected filters dropdown list ([#7583](https://github.com/kestra-io/kestra/pull/7583))
+- Introduce Devcontainer setup ([#7507](https://github.com/kestra-io/kestra/pull/7507))
+- **translations:** Standalone action for translations ([#7597](https://github.com/kestra-io/kestra/pull/7597))
+- **translations:** Localize to languages other than English ([#7605](https://github.com/kestra-io/kestra/pull/7605))
+- **translations:** Localize to languages other than English " ([#7605](https://github.com/kestra-io/kestra/pull/7605), [#7609](https://github.com/kestra-io/kestra/pull/7609))
+- **translations:** Localize to languages other than English ([#7610](https://github.com/kestra-io/kestra/pull/7610))
+- **translations:** Localize to languages other than English ([#7613](https://github.com/kestra-io/kestra/pull/7613))
+- **translations:** Localize to languages other than English ([#7618](https://github.com/kestra-io/kestra/pull/7618))
+- **ui:** Improve label for text search in filters section ([#7631](https://github.com/kestra-io/kestra/pull/7631))
+- **translations:** Localize to languages other than English ([#7633](https://github.com/kestra-io/kestra/pull/7633))
+- **ui:** Remove crud details from execution overview ([#7634](https://github.com/kestra-io/kestra/pull/7634))
+- **ui:** Improve empty state of the namespace files editor ([#7495](https://github.com/kestra-io/kestra/pull/7495))
+- **translations:** Localize to languages other than English ([#7635](https://github.com/kestra-io/kestra/pull/7635))
+- **core:** Eval value property once for flowable task Switch ([bfd82e0b5](https://github.com/kestra-io/kestra/commit/bfd82e0b5))
+- **ui:** Improve the topology tooltip label for adding task button ([#7656](https://github.com/kestra-io/kestra/pull/7656))
+- **ui:** Properly sanitize markdown content before rendering ([#7662](https://github.com/kestra-io/kestra/pull/7662))
+- **ui:** Make sure chart stacks are following the same order every time ([#7664](https://github.com/kestra-io/kestra/pull/7664))
+- **ui:** Properly sanitize markdown content before rendering ([#7697](https://github.com/kestra-io/kestra/pull/7697))
+- **ui:** Auto expand first element in execution overview cascaders ([#7715](https://github.com/kestra-io/kestra/pull/7715))
+- **core:** Make registry unregister usable with immutable list ([9a56b763f](https://github.com/kestra-io/kestra/commit/9a56b763f))
+- **ui:** Properly sanitize markdown content before rendering ([#7724](https://github.com/kestra-io/kestra/pull/7724))
+- **ui:** Uniforming empty state for components ([#7737](https://github.com/kestra-io/kestra/pull/7737))
+- **translations:** Localize to languages other than English ([#7739](https://github.com/kestra-io/kestra/pull/7739))
+- **ui:** Use uniformed pagination component for custom dashboard tables ([#7744](https://github.com/kestra-io/kestra/pull/7744))
+- **translations:** Localize to languages other than English ([#7746](https://github.com/kestra-io/kestra/pull/7746))
+- **ui:** Remove single empty space between label key and value so it can be copied ([#7774](https://github.com/kestra-io/kestra/pull/7774))
+- **ui:** Re-order namespace tabs ([#7778](https://github.com/kestra-io/kestra/pull/7778))
+- **translations:** Localize to languages other than English ([#7780](https://github.com/kestra-io/kestra/pull/7780))
+- **ui:** Respect line numbers prop as part of editor options ([#7781](https://github.com/kestra-io/kestra/pull/7781))
+- **core:** Disable OTLP metrics on tests ([c60676052](https://github.com/kestra-io/kestra/commit/c60676052))
+- Update ui-libs ([14ff4438f](https://github.com/kestra-io/kestra/commit/14ff4438f))
+- **ui:** Add the ability to change word wrap and to copy the preview output content ([#7801](https://github.com/kestra-io/kestra/pull/7801))
+- **translations:** Localize to languages other than English ([#7803](https://github.com/kestra-io/kestra/pull/7803))
+- **translations:** Localize to languages other than English ([#7863](https://github.com/kestra-io/kestra/pull/7863))
+- **ui:** Re-organize visuals for empty state component ([#7866](https://github.com/kestra-io/kestra/pull/7866))
+- **ui:** Prevent node state history to be shown if there is no date present ([#7867](https://github.com/kestra-io/kestra/pull/7867))
+- **core:** Add PluginVersioning interface and version for TaskRunner ([bed11f154](https://github.com/kestra-io/kestra/commit/bed11f154))
+- **ui:** Re-organize visuals for empty state component ([#7875](https://github.com/kestra-io/kestra/pull/7875))
+- **ui:** Complete refactor of yaml utils ([#7888](https://github.com/kestra-io/kestra/pull/7888))
+- **ui:** Create flow button on welcome page to start product tour ([#7906](https://github.com/kestra-io/kestra/pull/7906))
+- **translations:** Localize to languages other than English ([#7908](https://github.com/kestra-io/kestra/pull/7908))
+- **ui:** Show loading skeletons on dashboard ([#7417](https://github.com/kestra-io/kestra/pull/7417))
+- **ui:** Use the correct shadow on charts ([#7752](https://github.com/kestra-io/kestra/pull/7752))
+- **ui:** Change display on gantt page for created & queued executions ([#7706](https://github.com/kestra-io/kestra/pull/7706))
+- **ui:** Improve charts horizontal scrollbar ([#7508](https://github.com/kestra-io/kestra/pull/7508))
+- **translations:** Localize to languages other than English ([#7909](https://github.com/kestra-io/kestra/pull/7909))
+- **core:** Merge outputs only when necessary ([355e24c9d](https://github.com/kestra-io/kestra/commit/355e24c9d))
+- **ui:** Properly sanitize execution errors markdown content before rendering ([#7914](https://github.com/kestra-io/kestra/pull/7914))
+- **translations:** Localize to languages other than English ([#7915](https://github.com/kestra-io/kestra/pull/7915))
+- **translations:** Localize to languages other than English ([#7918](https://github.com/kestra-io/kestra/pull/7918))
+- **translations:** Localize to languages other than English ([#7929](https://github.com/kestra-io/kestra/pull/7929))
+- **ui:** Remove the flow topology control button from image export ([#7937](https://github.com/kestra-io/kestra/pull/7937))
+- **ui:** Introduce a refresh functionality to execution logs page ([#7946](https://github.com/kestra-io/kestra/pull/7946))
+- Add jattach into our Docker image ([fe944ccc5](https://github.com/kestra-io/kestra/commit/fe944ccc5))
+- Add GraalVM plugin ([43f1374aa](https://github.com/kestra-io/kestra/commit/43f1374aa))
+- **ui:** Removing dynamic section of collapsible plugin properties ([#8008](https://github.com/kestra-io/kestra/pull/8008))
+- **ui:** Highlight first item in global search bar autocomplete ([#8009](https://github.com/kestra-io/kestra/pull/8009))
+- Refactor StorageInterfaceFactory to be a bean ([fe7c14c04](https://github.com/kestra-io/kestra/commit/fe7c14c04))
+- **ui:** Add anchors to plugin documentation ([#8014](https://github.com/kestra-io/kestra/pull/8014))
+- **translations:** Localize to languages other than English ([#8013](https://github.com/kestra-io/kestra/pull/8013))
+- **ui:** Limit flow run dialog maximum height ([#7938](https://github.com/kestra-io/kestra/pull/7938))
+- **ci:** Lower build-artifacts workflow so github release can use it ([2a002e953](https://github.com/kestra-io/kestra/commit/2a002e953))
+- Upgrade to version 'v0.22.0-rc1-SNAPSHOT' ([8617eb0c7](https://github.com/kestra-io/kestra/commit/8617eb0c7))
+- **ci:** Pass plugin version to docker workflow ([771e841d7](https://github.com/kestra-io/kestra/commit/771e841d7))
+- **translations:** Localize to languages other than English ([#8071](https://github.com/kestra-io/kestra/pull/8071))
+- **ui:** Improve saved search filtering functionality ([#8073](https://github.com/kestra-io/kestra/pull/8073))
+- **ui:** Make app & dashboard editors re-sizable ([#8096](https://github.com/kestra-io/kestra/pull/8096))
+- **ui:** Include labels of saved search filter on page reload ([#8099](https://github.com/kestra-io/kestra/pull/8099))
+- **ui:** Pass custom height property to execution output debug editors ([#8100](https://github.com/kestra-io/kestra/pull/8100))
+- **ui:** Handle editor blueprint loading problem ([#8113](https://github.com/kestra-io/kestra/pull/8113))
+- **ui:** Amend file tree context menu link colors ([#8123](https://github.com/kestra-io/kestra/pull/8123))
+- **ui:** Add padlock icon to secrets menu item ([#8129](https://github.com/kestra-io/kestra/pull/8129))
+- Upgrade to version 'v0.22.0-rc2-SNAPSHOT' ([a88470886](https://github.com/kestra-io/kestra/commit/a88470886))
+- **ui:** Show blueprint `id` field in case of missing title ([#8154](https://github.com/kestra-io/kestra/pull/8154))
+- Disable tests that are too flaky ([822a3b438](https://github.com/kestra-io/kestra/commit/822a3b438))
+- Upgrade to v0.22.0-rc3-SNAPSHOT ([08579cf55](https://github.com/kestra-io/kestra/commit/08579cf55))
+- Version v0.22.0-rc4-SNAPSHOT ([ed58b7b5b](https://github.com/kestra-io/kestra/commit/ed58b7b5b))
+- Upgrade to v0.22.0 ([c5f2901f7](https://github.com/kestra-io/kestra/commit/c5f2901f7))
+
+### ✅ Tests
+
+- **webserver:** Flaky ExecutionControllerTest for kill ([#7368](https://github.com/kestra-io/kestra/pull/7368))
+
+### 🤖 CI
+
+- Update workflow docker ([84a30d400](https://github.com/kestra-io/kestra/commit/84a30d400))
+- Update workflow docker ([f96cbf1ad](https://github.com/kestra-io/kestra/commit/f96cbf1ad))
+- Fix workflow docker ([fde739a3b](https://github.com/kestra-io/kestra/commit/fde739a3b))
+- Fix workflow docker for all plugins ([d4d8e326e](https://github.com/kestra-io/kestra/commit/d4d8e326e))
+- Fix release workflows ([e2b67f253](https://github.com/kestra-io/kestra/commit/e2b67f253))
+- Cleanup ([d657f4827](https://github.com/kestra-io/kestra/commit/d657f4827))
+- **docker:** Fixed version of qemu ([49fe36250](https://github.com/kestra-io/kestra/commit/49fe36250))
+- **docker:** Revert fixed qemu version ([cfc0c9f9f](https://github.com/kestra-io/kestra/commit/cfc0c9f9f))
+- **publish-docker:** Attempts with ubuntu 0.20 ([#7431](https://github.com/kestra-io/kestra/pull/7431))
+- **publish-docker:** Attempts with command on qemu docker image ([a89ef7158](https://github.com/kestra-io/kestra/commit/a89ef7158))
+- **test:** Force test if ref is a tag ([a020e3f3a](https://github.com/kestra-io/kestra/commit/a020e3f3a))
+
+### ⚠️ Breaking Changes
+
+### EE: Default tenant deprecation
+
+Multi-tenancy was introduced in Kestra 0.13. For backward compatibility with older versions (≤0.12), you could use the concept of a default tenant, which imitated the multitenancy feature with the so-called “null”-tenant. One and a half years later, in Kestra 0.22, we are deprecating the default tenant functionality and plan to remove it in the future. We will provide a detailed migration guide for all customers who still use the default tenant. Until then, you can continue using `defaultTenant` by setting the corresponding configuration flag to `true`:
+
+```yaml
+kestra:
+  tenants:
+    enabled: true
+    defaultTenant: true
+```
+
+Note that in Kestra 0.22 and higher, `defaultTenant` is NOT enabled by default, so you must explicitly set that configuration option to `true` to keep using the default tenant.
+
+Also, keep in mind that prior to Kestra 0.22, `tenants.enabled` was by default set to `false` and now they are enabled.
+
+### EE: Azure log exporter
+
+The log exporter plugin for Azure `io.kestra.plugin.ee.azure.LogExporter`, introduced in Kestra 0.21, got split into two `io.kestra.plugin.ee.azure.monitor.LogExporter` and `io.kestra.plugin.ee.azure.storage.LogExporter` to reflect that you can now export your log to Azure either using Azure Monitor or using Azure Blob Storage.
+
+### EE: Enterprise Edition API changes
+
+Before Kestra 0.22, the Service Account name had to be globally unique within the instance. As a result, attempting to create a Service Account `cicd` in a `dev` tenant would raise an error `"Username already exists"` if your `prod` tenant also has a Service Account with the name `cicd`. 
+
+To support multiple service accounts with the same name, we’ve renamed the `username` property to `name` in the JSON payload for the following REST API endpoint: `POST /api/v1{/tenant}/users/service-accounts{/id}`.
+
+### EE: Too many failed login attempts now lock the account
+
+To improve the security of your Enterprise Edition instance, we now automatically lock user accounts after a `threshold` number of failed login attempts made within `monitoring-window`. Both, the number of failed attempts, the monitoring window to track consecutive number of failed attempts and (soon) the duration of how long the user remains locked are configurable.
+
+```yaml
+security:
+  login:
+    failed-attempts:
+      threshold: 10
+      monitoring-window: PT15M    # period to count failed attempts
+      # lockout-duration: PT24H      # period the account remains locked — will be added in the next release
+```
+
+Note that this change is only relevant for users who leverage LDAP or basic authentication (not relevant for SSO-users). Superadmin can unlock the user manually by resetting their password from the user's detail page.
+
+### Change to `readinessProbe` and `livenessProbe`
+
+Before [this PR](https://github.com/kestra-io/helm-charts/pull/62/files), both probes pointed to `/health`. This caused Kubernetes to restart the pod when an external component was unavailable. To resolve this, we updated the value file to configure the liveness and readiness probes to use the health paths recommended by Micronaut:
+
+- Liveness probe now points to `/health/liveness`
+- Readiness probe now points to `/health/readiness`.
+
+### Plugins using the `version` property
+
+With the introduction of plugin versioning, we reserve the `version` keyword for internal use, allowing us to specify the Kestra plugin version. As a result, we’ve renamed the `version` property for a few plugins that already used it, incl. the following:
+
+- `io.kestra.plugin.elasticsearch.Get` → renamed as `docVersion`
+- `io.kestra.plugin.opensearch.Get` → renamed as `docVersion`
+- `io.kestra.plugin.mqtt.RealtimeTrigger` → renamed as `mqttVersion`
+- `io.kestra.plugin.mqtt.Trigger` → renamed as `mqttVersion`
+- `io.kestra.plugin.serdes.parquet.IonToParquet` → renamed as `parquetVersion`
+
+Note that your **custom plugins** will need an equivalent approach of renaming any plugin that uses the `version` property, as this is now a core property reserved for plugin management. If any of your custom plugins rely on a `version` property, they won't compile anymore unless you rename that property to a different name.
+
+### Change in the default value for the `kv()` function
+
+Before Kestra 0.22, the `kv()` function had the property `errorOnMissing` set to `false` by default. We changed it to be `true` by default. If you want to keep the previous behavior of returning `null` without an error when attempting to fetch non-existing KV-pairs, use the syntax `"{{ kv('NON_EXISTING_KV_PAIR', errorOnMissing=false) }}"`.
+
+### ❤️ Contributors
+
+- Loïc Mathieu ([@loicmathieu](https://github.com/loicmathieu))
+- Barthélémy Ledoux <ledouxb@me.com>
+- Nicolas K. <nk_mikmak@hotmail.com>
+- Miloš Paunović ([@MilosPaunovic](https://github.com/MilosPaunovic))
+- Florian Hussonnois ([@fhussonnois](https://github.com/fhussonnois))
+- Brian.mulier ([@brian-mulier-p](https://github.com/brian-mulier-p))
+- Roman Acevedo <roman.acevedo62@gmail.com>
+- YannC <ycoornaert@kestra.io>
+- Yuri <1969yuri1969@gmail.com>
+- AJ Emerich <aemerich@kestra.io>
+- Satvik Kushwaha ([@satvik2131](https://github.com/satvik2131))
+- BenjoEK1337 ([@benjoEK1337](https://github.com/benjoEK1337))
+- Piyush Bhaskar ([@Piyush-r-bhaskar](https://github.com/Piyush-r-bhaskar))
+- Bart Ledoux <bledoux@kestra.io>
+- Yuri1969 <1969yuri1969@gmail.com>
+- Ludovic DEHON ([@tchiotludo](https://github.com/tchiotludo))
+- Rajatsingh23 ([@rajatsingh23](https://github.com/rajatsingh23))
+- Ash ([@Alessandra005](https://github.com/Alessandra005))
+- Will Russell ([@wrussell1999](https://github.com/wrussell1999))
+- Malay Dewangan ([@Malaydewangan09](https://github.com/Malaydewangan09))
+- Anna Geller <anna.m.geller@gmail.com>
+- Shruti Mantri <shruti1810@gmail.com>
+- NKwiatkowski <nkwiatkowski@kestra.io>
+- MilosPaunovic ([@MilosPaunovic](https://github.com/MilosPaunovic))
+- Harshit Dhaduk <harshitdhaduk5831@gmail.com>
+- Tanvir Ahmed ([@m-t-a97](https://github.com/m-t-a97))
+- Malaydewangan09 <malaydewangan310@gmail.com>
+- Đỗ Trọng Hải ([@hainenber](https://github.com/hainenber))
+- AeSouid <aesouid@kestra.io>
+- Adam Hirshson ([@Ahirshson02](https://github.com/Ahirshson02))
+- Mathieu Gabelle ([@mgabelle](https://github.com/mgabelle))
+- Aabhas Sao ([@aabhas-sao](https://github.com/aabhas-sao))
+- Laibrez <laishabj@gmail.com>
+- Eduardo Goncalvez ([@Edugre](https://github.com/Edugre))
+- Shamar ([@Shamar12334](https://github.com/Shamar12334))
+- Pravesh-Sudha ([@Pravesh-Sudha](https://github.com/Pravesh-Sudha))
+- ByronBlaze <pg903@snu.edu.in>
+- GitHub Action ([@Github-Action-Bot](https://github.com/Github-Action-Bot))
+- Dheeraj_R_Gowda ([@Dheerajr444](https://github.com/Dheerajr444))
+- 咬轮猫 <10928033@qq.com>
+- Amartknez <amartknez98@gmail.com>
+- Malay.worldref@gmail.com <malay@Malays-MacBook-Air.local>
+- Karthik73965 ([@Karthik73965](https://github.com/Karthik73965))
+- Brian-mulier-p ([@brian-mulier-p](https://github.com/brian-mulier-p))

build.gradle

@@ -31,12 +31,10 @@ plugins {
     id 'com.github.node-gradle.node' version '7.1.0'
 
     // release
-    id "io.github.gradle-nexus.publish-plugin" version "2.0.0"
     id 'net.researchgate.release' version '3.1.0'
     id "com.gorylenko.gradle-git-properties" version "2.5.0"
     id 'signing'
-    id 'ru.vyarus.pom' version '3.0.0' apply false
-    id 'ru.vyarus.github-info' version '2.0.0' apply false
+    id "com.vanniktech.maven.publish" version "0.33.0"
 
     // OWASP dependency check
     id "org.owasp.dependencycheck" version "12.1.0" apply false
@@ -196,6 +194,8 @@ subprojects {
             testImplementation 'org.hamcrest:hamcrest'
             testImplementation 'org.hamcrest:hamcrest-library'
             testImplementation 'org.exparity:hamcrest-date'
+
+            testImplementation 'org.assertj:assertj-core'
         }
 
         test {
@@ -411,6 +411,7 @@ distTar.dependsOn shadowJar
 startScripts.dependsOn shadowJar
 startShadowScripts.dependsOn jar
 shadowJar.dependsOn 'ui:assembleFrontend'
+shadowJar.dependsOn jar
 
 /**********************************************************************************************************************\
  * Executable Jar
@@ -472,114 +473,147 @@ tasks.register('runLocal', JavaExec) {
 /**********************************************************************************************************************\
  * Publish
  **********************************************************************************************************************/
-nexusPublishing {
-    repositoryDescription = "${project.group}:${rootProject.name}:${project.version}"
-    useStaging = !project.version.endsWith("-SNAPSHOT")
-    repositories {
-        sonatype {
-            nexusUrl.set(uri("https://s01.oss.sonatype.org/service/local/"))
-            snapshotRepositoryUrl.set(uri("https://s01.oss.sonatype.org/content/repositories/snapshots/"))
-        }
-    }
-}
+subprojects {subProject ->
 
-subprojects {
-    apply plugin: "maven-publish"
-    apply plugin: 'signing'
-    apply plugin: 'ru.vyarus.pom'
-    apply plugin: 'ru.vyarus.github-info'
+    if (subProject.name != 'jmh-benchmarks' && subProject.name != rootProject.name) {
+        apply plugin: 'signing'
+        apply plugin: "com.vanniktech.maven.publish"
 
-    javadoc {
-        options {
-            locale = 'en_US'
-            encoding = 'UTF-8'
-            addStringOption("Xdoclint:none", "-quiet")
-        }
-    }
-
-    tasks.register('sourcesJar', Jar) {
-        dependsOn = [':core:copyGradleProperties']
-        dependsOn = [':ui:assembleFrontend']
-        archiveClassifier.set('sources')
-        from sourceSets.main.allSource
-    }
-    sourcesJar.dependsOn ':core:copyGradleProperties'
-    sourcesJar.dependsOn ':ui:assembleFrontend'
-
-    tasks.register('javadocJar', Jar) {
-        archiveClassifier.set('javadoc')
-        from javadoc
-    }
-
-    tasks.register('testsJar', Jar) {
-        group = 'build'
-        description = 'Build the tests jar'
-
-        archiveClassifier.set('tests')
-        if (sourceSets.matching { it.name == 'test'}) {
-            from sourceSets.named('test').get().output
-        }
-    }
-
-    github {
-        user 'kestra-io'
-        license 'Apache'
-        repository 'kestra'
-        site 'https://kestra.io'
-    }
-
-    maven.pom {
-        description = 'The modern, scalable orchestrator & scheduler open source platform'
-
-        developers {
-            developer {
-                id = "tchiotludo"
-                name = "Ludovic Dehon"
+        javadoc {
+            options {
+                locale = 'en_US'
+                encoding = 'UTF-8'
+                addStringOption("Xdoclint:none", "-quiet")
             }
         }
-    }
 
-    publishing {
-        publications {
-            sonatypePublication(MavenPublication) {
-                version project.version
+        tasks.register('sourcesJar', Jar) {
+            dependsOn = [':core:copyGradleProperties']
+            dependsOn = [':ui:assembleFrontend']
+            archiveClassifier.set('sources')
+            from sourceSets.main.allSource
+        }
+        sourcesJar.dependsOn ':core:copyGradleProperties'
+        sourcesJar.dependsOn ':ui:assembleFrontend'
 
-                if (project.name.contains('cli')) {
-                    groupId "io.kestra"
-                    artifactId "kestra"
+        tasks.register('javadocJar', Jar) {
+            archiveClassifier.set('javadoc')
+            from javadoc
+        }
 
-                    artifact shadowJar
-                    artifact executableJar
-                } else if (project.name.contains('platform')){
-                    groupId project.group
-                    artifactId project.name
-                } else {
-                    from components.java
+        tasks.register('testsJar', Jar) {
+            group = 'build'
+            description = 'Build the tests jar'
 
-                    groupId project.group
-                    artifactId project.name
+            archiveClassifier.set('tests')
+            if (sourceSets.matching { it.name == 'test'}) {
+                from sourceSets.named('test').get().output
+            }
+        }
 
-                    artifact sourcesJar
-                    artifact javadocJar
-                    artifact testsJar
+        //These modules should not be published
+        def unpublishedModules = ["jdbc-mysql", "jdbc-postgres", "webserver"]
+        if (subProject.name in unpublishedModules){
+            return
+        }
+
+        mavenPublishing {
+            publishToMavenCentral(true)
+            signAllPublications()
+
+            coordinates(
+                "${rootProject.group}",
+                subProject.name == "cli" ? rootProject.name : subProject.name,
+                "${rootProject.version}"
+            )
+
+            pom {
+                name        = project.name
+                description = "${project.group}:${project.name}:${rootProject.version}"
+                url         = "https://github.com/kestra-io/${rootProject.name}"
+
+                licenses {
+                    license {
+                        name = "The Apache License, Version 2.0"
+                        url  = "http://www.apache.org/licenses/LICENSE-2.0.txt"
+                    }
+                }
+                developers {
+                    developer {
+                        id    = "tchiotludo"
+                        name  = "Ludovic Dehon"
+                        email = "ldehon@kestra.io"
+                    }
+                }
+                scm {
+                    connection = 'scm:git:'
+                    url = "https://github.com/kestra-io/${rootProject.name}"
                 }
             }
         }
-    }
 
-    signing {
-        // only sign JARs that we publish to Sonatype
-        required { gradle.taskGraph.hasTask("publishSonatypePublicationPublicationToSonatypeRepository") }
-        sign publishing.publications.sonatypePublication
-    }
+        afterEvaluate {
+            publishing {
+                publications {
+                    withType(MavenPublication).configureEach { publication ->
 
-    tasks.withType(GenerateModuleMetadata).configureEach {
-        // Suppression this validation error as we want to enforce the Kestra platform
-        suppressedValidationErrors.add('enforced-platform')
+                        if (subProject.name == "platform") {
+                            // Clear all artifacts except the BOM
+                            publication.artifacts.clear()
+                        }
+                    }
+                }
+            }
+        }
+
+        if (subProject.name == 'cli') {
+
+            /* Make sure the special publication is wired *after* every plugin */
+            subProject.afterEvaluate {
+                /* 1. Remove the default java component so Gradle stops expecting
+                       the standard cli-*.jar, sources, javadoc, etc.           */
+                components.removeAll { it.name == "java" }
+
+                /* 2. Replace the publication’s artifacts with shadow + exec */
+                publishing.publications.withType(MavenPublication).configureEach { pub ->
+                    pub.artifacts.clear()
+
+                    // main shadow JAR built at root
+                    pub.artifact(rootProject.tasks.named("shadowJar").get()) {
+                        extension = "jar"
+                    }
+
+                    // executable ZIP built at root
+                    pub.artifact(rootProject.tasks.named("executableJar").get().archiveFile) {
+                        classifier = "exec"
+                        extension  = "zip"
+                    }
+                    pub.artifact(tasks.named("sourcesJar").get())
+                    pub.artifact(tasks.named("javadocJar").get())
+
+                }
+
+                /* 3. Disable Gradle-module metadata for this publication to
+                       avoid the “artifact removed from java component” error. */
+                tasks.withType(GenerateModuleMetadata).configureEach { it.enabled = false }
+
+                /* 4. Make every publish task in :cli wait for the two artifacts */
+                tasks.matching { it.name.startsWith("publish") }.configureEach {
+                    dependsOn rootProject.tasks.named("shadowJar")
+                    dependsOn rootProject.tasks.named("executableJar")
+                }
+            }
+        }
+
+        tasks.withType(GenerateModuleMetadata).configureEach {
+            // Suppression this validation error as we want to enforce the Kestra platform
+            suppressedValidationErrors.add('enforced-platform')
+        }
     }
 }
 
 
+
 /**********************************************************************************************************************\
  * Version
  **********************************************************************************************************************/

cli/build.gradle

@@ -37,4 +37,4 @@ dependencies {
 
     //test
     testImplementation "org.wiremock:wiremock"
-}
+}

cli/src/main/java/io/kestra/cli/AbstractApiCommand.java

@@ -46,6 +46,13 @@ public abstract class AbstractApiCommand extends AbstractCommand {
     @Nullable
     private HttpClientConfiguration httpClientConfiguration;
 
+    /**
+     * {@inheritDoc}
+     */
+    protected boolean loadExternalPlugins() {
+        return false;
+    }
+
     protected DefaultHttpClient client() throws URISyntaxException {
         DefaultHttpClient defaultHttpClient = new DefaultHttpClient(server.toURI(), httpClientConfiguration != null ? httpClientConfiguration : new DefaultHttpClientConfiguration());
         MessageBodyHandlerRegistry defaultHandlerRegistry = defaultHttpClient.getHandlerRegistry();

cli/src/main/java/io/kestra/cli/AbstractValidateCommand.java

@@ -31,6 +31,12 @@ public abstract class AbstractValidateCommand extends AbstractApiCommand {
     @CommandLine.Parameters(index = "0", description = "the directory containing files to check")
     protected Path directory;
 
+    /** {@inheritDoc} **/
+    @Override
+    protected boolean loadExternalPlugins() {
+        return local;
+    }
+
     public static void handleException(ConstraintViolationException e, String resource) {
         stdErr("\t@|fg(red) Unable to parse {0} due to the following error(s):|@", resource);
         e.getConstraintViolations()

cli/src/main/java/io/kestra/cli/commands/flows/FlowCommand.java

@@ -18,6 +18,8 @@ import picocli.CommandLine;
         FlowNamespaceCommand.class,
         FlowDotCommand.class,
         FlowExportCommand.class,
+        FlowUpdateCommand.class,
+        FlowUpdatesCommand.class
     }
 )
 @Slf4j

cli/src/main/java/io/kestra/cli/commands/flows/FlowUpdatesCommand.java

@@ -87,4 +87,9 @@ public class FlowUpdatesCommand extends AbstractApiCommand {
 
         return 0;
     }
+
+    @Override
+    protected boolean loadExternalPlugins() {
+        return false;
+    }
 }

cli/src/main/java/io/kestra/cli/commands/plugins/PluginCommand.java

@@ -12,6 +12,7 @@ import picocli.CommandLine.Command;
     mixinStandardHelpOptions = true,
     subcommands = {
         PluginInstallCommand.class,
+        PluginUninstallCommand.class,
         PluginListCommand.class,
         PluginDocCommand.class,
         PluginSearchCommand.class

cli/src/main/java/io/kestra/cli/commands/plugins/PluginInstallCommand.java

@@ -1,6 +1,7 @@
 package io.kestra.cli.commands.plugins;
 
 import io.kestra.core.contexts.MavenPluginRepositoryConfig;
+import io.kestra.core.exceptions.KestraRuntimeException;
 import io.kestra.core.plugins.LocalPluginManager;
 import io.kestra.core.plugins.MavenPluginDownloader;
 import io.kestra.core.plugins.PluginArtifact;
@@ -51,7 +52,7 @@ public class PluginInstallCommand extends AbstractCommand {
     Provider<MavenPluginDownloader> mavenPluginRepositoryProvider;
 
     @Inject
-    @Client("api") HttpClient httpClient;
+    Provider<PluginCatalogService> pluginCatalogService;
 
     @Override
     public Integer call() throws Exception {
@@ -85,7 +86,7 @@ public class PluginInstallCommand extends AbstractCommand {
         }
 
         if (all) {
-            PluginCatalogService service = new PluginCatalogService(httpClient, false, true);
+            PluginCatalogService service = pluginCatalogService.get();
             dependencies = service.get().stream().map(Objects::toString).toList();
         }
 
@@ -103,12 +104,21 @@ public class PluginInstallCommand extends AbstractCommand {
         }
 
         try (final PluginManager pluginManager = getPluginManager()) {
-            List<PluginArtifact> installed = pluginManager.install(
-                pluginArtifacts,
-                repositoryConfigs,
-                false,
-                pluginsPath
-            );
+
+            List<PluginArtifact> installed;
+            if (all) {
+                installed = new ArrayList<>(pluginArtifacts.size());
+                for (PluginArtifact pluginArtifact : pluginArtifacts) {
+                    try {
+                        installed.add(pluginManager.install(pluginArtifact, repositoryConfigs, false, pluginsPath));
+                    } catch (KestraRuntimeException e) {
+                        String cause = e.getCause() != null ? e.getCause().getMessage() : e.getMessage();
+                        stdErr("Failed to install plugin {0}. Cause: {1}", pluginArtifact, cause);
+                    }
+                }
+            } else {
+                installed = pluginManager.install(pluginArtifacts, repositoryConfigs, false, pluginsPath);
+            }
 
             List<URI> uris = installed.stream().map(PluginArtifact::uri).toList();
             stdOut("Successfully installed plugins {0} into {1}", dependencies, uris);

cli/src/main/java/io/kestra/cli/commands/plugins/PluginUninstallCommand.java

@@ -17,10 +17,10 @@ import java.util.List;
 
 @CommandLine.Command(
     name = "uninstall",
-    description = "uninstall a plugin"
+    description = "Uninstall plugins"
 )
 public class PluginUninstallCommand extends AbstractCommand {
-    @Parameters(index = "0..*", description = "the plugins to uninstall")
+    @Parameters(index = "0..*", description = "The plugins to uninstall. Represented as Maven artifact coordinates (i.e., <groupId>:<artifactId>:(<version>|LATEST)")
     List<String> dependencies = new ArrayList<>();
 
     @Spec

cli/src/main/java/io/kestra/cli/commands/servers/StandAloneCommand.java

@@ -2,6 +2,7 @@ package io.kestra.cli.commands.servers;
 
 import com.google.common.collect.ImmutableMap;
 import io.kestra.cli.services.FileChangedEventListener;
+import io.kestra.core.contexts.KestraContext;
 import io.kestra.core.models.ServerType;
 import io.kestra.core.repositories.LocalFlowRepositoryLoader;
 import io.kestra.core.runners.StandAloneRunner;
@@ -88,9 +89,10 @@ public class StandAloneCommand extends AbstractServerCommand {
         this.skipExecutionService.setSkipFlows(skipFlows);
         this.skipExecutionService.setSkipNamespaces(skipNamespaces);
         this.skipExecutionService.setSkipTenants(skipTenants);
-
         this.startExecutorService.applyOptions(startExecutors, notStartExecutors);
 
+        KestraContext.getContext().injectWorkerConfigs(workerThread, null);
+
         super.call();
 
         if (flowPath != null) {

cli/src/main/java/io/kestra/cli/commands/servers/WorkerCommand.java

@@ -1,6 +1,7 @@
 package io.kestra.cli.commands.servers;
 
 import com.google.common.collect.ImmutableMap;
+import io.kestra.core.contexts.KestraContext;
 import io.kestra.core.models.ServerType;
 import io.kestra.core.runners.Worker;
 import io.kestra.core.utils.Await;
@@ -36,7 +37,11 @@ public class WorkerCommand extends AbstractServerCommand {
 
     @Override
     public Integer call() throws Exception {
+
+        KestraContext.getContext().injectWorkerConfigs(thread, workerGroupKey);
+
         super.call();
+
         if (this.workerGroupKey != null && !this.workerGroupKey.matches("[a-zA-Z0-9_-]+")) {
             throw new IllegalArgumentException("The --worker-group option must match the [a-zA-Z0-9_-]+ pattern");
         }

cli/src/main/resources/application.yml

@@ -15,6 +15,9 @@ micronaut:
       static:
         paths: classpath:static
         mapping: /static/**
+      root:
+        paths: classpath:root
+        mapping: /**
   server:
     max-request-size: 10GB
     multipart:

cli/src/test/java/io/kestra/cli/commands/flows/FlowExportCommandTest.java

@@ -32,6 +32,8 @@ class FlowExportCommandTest {
 
             // we use the update command to add flows to extract
             String[] updateArgs = {
+                "--plugins",
+                "/tmp", // pass this arg because it can cause failure
                 "--server",
                 embeddedServer.getURL().toString(),
                 "--user",
@@ -44,6 +46,8 @@ class FlowExportCommandTest {
 
             // then we export them
             String[] exportArgs = {
+                "--plugins",
+                "/tmp", // pass this arg because it can cause failure
                 "--server",
                 embeddedServer.getURL().toString(),
                 "--user",

cli/src/test/java/io/kestra/cli/commands/flows/FlowUpdatesCommandTest.java

@@ -28,6 +28,8 @@ class FlowUpdatesCommandTest {
             embeddedServer.start();
 
             String[] args = {
+                "--plugins",
+                "/tmp", // pass this arg because it can cause failure
                 "--server",
                 embeddedServer.getURL().toString(),
                 "--user",
@@ -41,6 +43,8 @@ class FlowUpdatesCommandTest {
             out.reset();
 
             args = new String[]{
+                "--plugins",
+                "/tmp", // pass this arg because it can cause failure
                 "--server",
                 embeddedServer.getURL().toString(),
                 "--user",
@@ -70,6 +74,8 @@ class FlowUpdatesCommandTest {
             embeddedServer.start();
 
             String[] args = {
+                "--plugins",
+                "/tmp", // pass this arg because it can cause failure
                 "--server",
                 embeddedServer.getURL().toString(),
                 "--user",
@@ -84,6 +90,8 @@ class FlowUpdatesCommandTest {
 
             // no "delete" arg should behave as no-delete
             args = new String[]{
+                "--plugins",
+                "/tmp", // pass this arg because it can cause failure
                 "--server",
                 embeddedServer.getURL().toString(),
                 "--user",
@@ -96,6 +104,8 @@ class FlowUpdatesCommandTest {
             out.reset();
 
             args = new String[]{
+                "--plugins",
+                "/tmp", // pass this arg because it can cause failure
                 "--server",
                 embeddedServer.getURL().toString(),
                 "--user",
@@ -121,6 +131,8 @@ class FlowUpdatesCommandTest {
             embeddedServer.start();
 
             String[] args = {
+                "--plugins",
+                "/tmp", // pass this arg because it can cause failure
                 "--server",
                 embeddedServer.getURL().toString(),
                 "--user",
@@ -148,6 +160,8 @@ class FlowUpdatesCommandTest {
             embeddedServer.start();
 
             String[] args = {
+                "--plugins",
+                "/tmp", // pass this arg because it can cause failure
                 "--server",
                 embeddedServer.getURL().toString(),
                 "--user",

cli/src/test/java/io/kestra/cli/commands/flows/TemplateValidateCommandTest.java

@@ -46,6 +46,8 @@ class TemplateValidateCommandTest {
             embeddedServer.start();
 
             String[] args = {
+                "--plugins",
+                "/tmp", // pass this arg because it can cause failure
                 "--server",
                 embeddedServer.getURL().toString(),
                 "--user",

cli/src/test/java/io/kestra/cli/commands/namespaces/files/NamespaceFilesUpdateCommandTest.java

@@ -31,6 +31,8 @@ class NamespaceFilesUpdateCommandTest {
 
             String to = "/some/directory";
             String[] args = {
+                "--plugins",
+                "/tmp", // pass this arg because it can cause failure
                 "--server",
                 embeddedServer.getURL().toString(),
                 "--user",
@@ -61,6 +63,8 @@ class NamespaceFilesUpdateCommandTest {
             embeddedServer.start();
 
             String[] args = {
+                "--plugins",
+                "/tmp", // pass this arg because it can cause failure
                 "--server",
                 embeddedServer.getURL().toString(),
                 "--user",
@@ -90,6 +94,8 @@ class NamespaceFilesUpdateCommandTest {
             embeddedServer.start();
 
             String[] args = {
+                "--plugins",
+                "/tmp", // pass this arg because it can cause failure
                 "--server",
                 embeddedServer.getURL().toString(),
                 "--user",

cli/src/test/java/io/kestra/cli/commands/namespaces/kv/KvUpdateCommandTest.java

@@ -28,6 +28,8 @@ class KvUpdateCommandTest {
             embeddedServer.start();
 
             String[] args = {
+                "--plugins",
+                "/tmp", // pass this arg because it can cause failure
                 "--server",
                 embeddedServer.getURL().toString(),
                 "--user",
@@ -54,6 +56,8 @@ class KvUpdateCommandTest {
             embeddedServer.start();
 
             String[] args = {
+                "--plugins",
+                "/tmp", // pass this arg because it can cause failure
                 "--server",
                 embeddedServer.getURL().toString(),
                 "--user",
@@ -80,6 +84,8 @@ class KvUpdateCommandTest {
             embeddedServer.start();
 
             String[] args = {
+                "--plugins",
+                "/tmp", // pass this arg because it can cause failure
                 "--server",
                 embeddedServer.getURL().toString(),
                 "--user",
@@ -108,6 +114,8 @@ class KvUpdateCommandTest {
             embeddedServer.start();
 
             String[] args = {
+                "--plugins",
+                "/tmp", // pass this arg because it can cause failure
                 "--server",
                 embeddedServer.getURL().toString(),
                 "--user",
@@ -134,6 +142,8 @@ class KvUpdateCommandTest {
             embeddedServer.start();
 
             String[] args = {
+                "--plugins",
+                "/tmp", // pass this arg because it can cause failure
                 "--server",
                 embeddedServer.getURL().toString(),
                 "--user",
@@ -167,6 +177,8 @@ class KvUpdateCommandTest {
             Files.write(file.toPath(), "{\"some\":\"json\",\"from\":\"file\"}".getBytes());
 
             String[] args = {
+                "--plugins",
+                "/tmp", // pass this arg because it can cause failure
                 "--server",
                 embeddedServer.getURL().toString(),
                 "--user",

core/build.gradle

@@ -36,6 +36,7 @@ dependencies {
     implementation group: 'de.focus-shift', name: 'jollyday-jaxb'
     implementation 'nl.basjes.gitignore:gitignore-reader'
     implementation group: 'dev.failsafe', name: 'failsafe'
+    implementation 'com.github.ben-manes.caffeine:caffeine'
     api 'org.apache.httpcomponents.client5:httpclient5'
 
     // plugins

core/src/main/java/io/kestra/core/cache/NoopCache.java

@@ -0,0 +1,92 @@
+package io.kestra.core.cache;
+
+import com.github.benmanes.caffeine.cache.Cache;
+import com.github.benmanes.caffeine.cache.Policy;
+import com.github.benmanes.caffeine.cache.stats.CacheStats;
+import org.jspecify.annotations.NonNull;
+import org.jspecify.annotations.Nullable;
+
+import java.util.Collections;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.function.Function;
+
+/**
+ * A No-Op implementation of a Caffeine Cache.
+ * Useful to disable caching but still use a cache to avoid if/else chains
+ */
+public class NoopCache<K, V> implements Cache<K, V> {
+    private static final ConcurrentMap<?, ?> EMPTY_MAP = new ConcurrentHashMap<>(0);
+
+    @Override
+    public @Nullable V getIfPresent(K key) {
+        return null;
+    }
+
+    @Override
+    public V get(K key, Function<? super K, ? extends V> mappingFunction) {
+        return mappingFunction.apply(key);
+    }
+
+    @Override
+    public Map<K, @NonNull V> getAllPresent(Iterable<? extends K> keys) {
+        return Collections.emptyMap();
+    }
+
+    @Override
+    public Map<K, @NonNull V> getAll(Iterable<? extends K> keys, Function<? super Set<? extends K>, ? extends Map<? extends K, ? extends @NonNull V>> mappingFunction) {
+        return Collections.emptyMap();
+    }
+
+    @Override
+    public void put(K key, @NonNull V value) {
+        // just do nothing
+    }
+
+    @Override
+    public void putAll(Map<? extends K, ? extends @NonNull V> map) {
+        // just do nothing
+    }
+
+    @Override
+    public void invalidate(K key) {
+        // just do nothing
+    }
+
+    @Override
+    public void invalidateAll(Iterable<? extends K> keys) {
+        // just do nothing
+    }
+
+    @Override
+    public void invalidateAll() {
+        // just do nothing
+    }
+
+    @Override
+    public long estimatedSize() {
+        return 0;
+    }
+
+    @Override
+    public CacheStats stats() {
+        return CacheStats.empty();
+    }
+
+    @Override
+    public ConcurrentMap<K, @NonNull V> asMap() {
+        return (ConcurrentMap<K, V>) EMPTY_MAP;
+    }
+
+    @Override
+    public void cleanUp() {
+        // just do nothing
+    }
+
+    @Override
+    public Policy<K, @NonNull V> policy() {
+        throw new UnsupportedOperationException();
+    }
+}

core/src/main/java/io/kestra/core/contexts/KestraBeansFactory.java

@@ -2,6 +2,7 @@ package io.kestra.core.contexts;
 
 import io.kestra.core.exceptions.KestraRuntimeException;
 import io.kestra.core.plugins.DefaultPluginRegistry;
+import io.kestra.core.plugins.PluginCatalogService;
 import io.kestra.core.plugins.PluginRegistry;
 import io.kestra.core.storages.StorageInterface;
 import io.kestra.core.storages.StorageInterfaceFactory;
@@ -13,6 +14,8 @@ import io.micronaut.context.annotation.Value;
 import io.micronaut.core.annotation.Nullable;
 import io.micronaut.core.convert.format.MapFormat;
 import io.micronaut.core.naming.conventions.StringConvention;
+import io.micronaut.http.client.HttpClient;
+import io.micronaut.http.client.annotation.Client;
 import jakarta.inject.Inject;
 import jakarta.inject.Singleton;
 import jakarta.validation.Validator;
@@ -35,6 +38,11 @@ public class KestraBeansFactory {
     @Value("${kestra.storage.type}")
     protected Optional<String> storageType;
 
+    @Singleton
+    public PluginCatalogService pluginCatalogService(@Client("api") HttpClient httpClient) {
+        return new PluginCatalogService(httpClient, false, true);
+    }
+
     @Requires(missingBeans = PluginRegistry.class)
     @Singleton
     public PluginRegistry pluginRegistry() {

core/src/main/java/io/kestra/core/contexts/KestraContext.java

@@ -10,6 +10,8 @@ import io.micronaut.context.env.Environment;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.util.HashMap;
+import java.util.Map;
 import java.util.Optional;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
@@ -27,6 +29,10 @@ public abstract class KestraContext {
     // Properties
     public static final String KESTRA_SERVER_TYPE = "kestra.server-type";
 
+    // Those properties are injected bases on the CLI args.
+    private static final String KESTRA_WORKER_MAX_NUM_THREADS = "kestra.worker.max-num-threads";
+    private static final String KESTRA_WORKER_GROUP_KEY = "kestra.worker.group-key";
+
     /**
      * Gets the current {@link KestraContext}.
      *
@@ -54,6 +60,12 @@ public abstract class KestraContext {
      */
     public abstract ServerType getServerType();
 
+    public abstract Optional<Integer> getWorkerMaxNumThreads();
+
+    public abstract Optional<String> getWorkerGroupKey();
+
+    public abstract void injectWorkerConfigs(Integer maxNumThreads, String workerGroupKey);
+
     /**
      * Returns the Kestra Version.
      *
@@ -110,6 +122,34 @@ public abstract class KestraContext {
                 .orElse(ServerType.STANDALONE);
         }
 
+        /** {@inheritDoc} **/
+        @Override
+        public Optional<Integer> getWorkerMaxNumThreads() {
+            return Optional.ofNullable(environment)
+                .flatMap(env -> env.getProperty(KESTRA_WORKER_MAX_NUM_THREADS, Integer.class));
+        }
+
+        /** {@inheritDoc} **/
+        @Override
+        public Optional<String> getWorkerGroupKey() {
+            return Optional.ofNullable(environment)
+                .flatMap(env -> env.getProperty(KESTRA_WORKER_GROUP_KEY, String.class));
+        }
+        /** {@inheritDoc} **/
+        @Override
+        public void injectWorkerConfigs(Integer maxNumThreads, String workerGroupKey) {
+            final Map<String, Object> configs = new HashMap<>();
+            Optional.ofNullable(maxNumThreads)
+                .ifPresent(val -> configs.put(KESTRA_WORKER_MAX_NUM_THREADS, val));
+
+            Optional.ofNullable(workerGroupKey)
+                .ifPresent(val -> configs.put(KESTRA_WORKER_GROUP_KEY, val));
+
+            if (!configs.isEmpty()) {
+                environment.addPropertySource("kestra-runtime", configs);
+            }
+        }
+
         /** {@inheritDoc} **/
         @Override
         public void shutdown() {

core/src/main/java/io/kestra/core/docs/DocumentationGenerator.java

@@ -7,6 +7,7 @@ import io.kestra.core.models.tasks.logs.LogExporter;
 import io.kestra.core.models.tasks.runners.TaskRunner;
 import io.kestra.core.models.tasks.Task;
 import io.kestra.core.models.triggers.AbstractTrigger;
+import io.kestra.core.plugins.AdditionalPlugin;
 import io.kestra.core.plugins.PluginClassAndMetadata;
 import io.kestra.core.plugins.RegisteredPlugin;
 import io.kestra.core.runners.pebble.Extension;
@@ -75,6 +76,7 @@ public class DocumentationGenerator {
         //noinspection unchecked
         result.addAll(this.generate(registeredPlugin, registeredPlugin.getTaskRunners(), (Class) TaskRunner.class, "task-runners"));
         result.addAll(this.generate(registeredPlugin, registeredPlugin.getLogExporters(), (Class) LogExporter.class, "log-exporters"));
+        result.addAll(this.generate(registeredPlugin, registeredPlugin.getAdditionalPlugins(), AdditionalPlugin.class, "additional-plugins"));
 
         result.addAll(guides(registeredPlugin));
 

core/src/main/java/io/kestra/core/docs/JsonSchemaGenerator.java

@@ -31,6 +31,7 @@ import io.kestra.core.models.tasks.common.EncryptedString;
 import io.kestra.core.models.tasks.logs.LogExporter;
 import io.kestra.core.models.tasks.runners.TaskRunner;
 import io.kestra.core.models.triggers.AbstractTrigger;
+import io.kestra.core.plugins.AdditionalPlugin;
 import io.kestra.core.plugins.PluginRegistry;
 import io.kestra.core.plugins.RegisteredPlugin;
 import io.kestra.core.serializers.JacksonMapper;
@@ -50,6 +51,7 @@ import java.util.stream.StreamSupport;
 @Singleton
 public class JsonSchemaGenerator {
     private static final List<Class<?>> TYPES_RESOLVED_AS_STRING = List.of(Duration.class, LocalTime.class, LocalDate.class, LocalDateTime.class, ZonedDateTime.class, OffsetDateTime.class, OffsetTime.class);
+    private static final List<Class<?>> SUBTYPE_RESOLUTION_EXCLUSION_FOR_PLUGIN_SCHEMA = List.of(Task.class, AbstractTrigger.class);
 
     private final PluginRegistry pluginRegistry;
 
@@ -81,7 +83,7 @@ public class JsonSchemaGenerator {
                 objectNode.put("type", "array");
             }
             replaceAnyOfWithOneOf(objectNode);
-            pullOfDefaultFromOneOf(objectNode);
+            pullDocumentationAndDefaultFromOneOf(objectNode);
             removeRequiredOnPropsWithDefaults(objectNode);
 
             return JacksonMapper.toMap(objectNode);
@@ -122,22 +124,35 @@ public class JsonSchemaGenerator {
     // This hack exists because for Property we generate a oneOf for properties that are not strings.
     // By default, the 'default' is in each oneOf which Monaco editor didn't take into account.
     // So, we pull off the 'default' from any of the oneOf to the parent.
-    private void pullOfDefaultFromOneOf(ObjectNode objectNode) {
+    // same thing for documentation fields: 'title', 'description', '$deprecated'
+    private void pullDocumentationAndDefaultFromOneOf(ObjectNode objectNode) {
         objectNode.findParents("oneOf").forEach(jsonNode -> {
             if (jsonNode instanceof ObjectNode oNode) {
                 JsonNode oneOf = oNode.get("oneOf");
                 if (oneOf instanceof ArrayNode arrayNode) {
                     Iterator<JsonNode> it = arrayNode.elements();
-                    JsonNode defaultNode = null;
-                    while (it.hasNext() && defaultNode == null) {
+                    var nodesToPullUp = new HashMap<String, Optional<JsonNode>>(Map.ofEntries(
+                        Map.entry("default", Optional.empty()),
+                        Map.entry("title", Optional.empty()),
+                        Map.entry("description", Optional.empty()),
+                        Map.entry("$deprecated", Optional.empty())
+                    ));
+                    // find nodes to pull up
+                    while (it.hasNext() && nodesToPullUp.containsValue(Optional.<JsonNode>empty())) {
                         JsonNode next = it.next();
                         if (next instanceof ObjectNode nextAsObj) {
-                            defaultNode = nextAsObj.get("default");
+                            nodesToPullUp.entrySet().stream()
+                                .filter(node -> node.getValue().isEmpty())
+                                .forEach(node -> node
+                                    .setValue(Optional.ofNullable(
+                                        nextAsObj.get(node.getKey())
+                                    )));
                         }
                     }
-                    if (defaultNode != null) {
-                        oNode.set("default", defaultNode);
-                    }
+                    // create nodes on parent
+                    nodesToPullUp.entrySet().stream()
+                        .filter(node -> node.getValue().isPresent())
+                        .forEach(node -> oNode.set(node.getKey(), node.getValue().get()));
                 }
             }
         });
@@ -486,21 +501,32 @@ public class JsonSchemaGenerator {
                     collectedTypeAttributes.remove("$examples");
                 }
             });
+        } else {
+            builder.forTypesInGeneral()
+                .withSubtypeResolver((declaredType, context) -> {
+                    TypeContext typeContext = context.getTypeContext();
 
-            // Ensure that `type` is defined as a constant in JSON Schema.
-            // The `const` property is used by editors for auto-completion based on that schema.
-            builder.forTypesInGeneral().withTypeAttributeOverride((collectedTypeAttributes, scope, context) -> {
-                final Class<?> pluginType = scope.getType().getErasedType();
-                if (pluginType.getAnnotation(Plugin.class) != null) {
-                    ObjectNode properties = (ObjectNode) collectedTypeAttributes.get("properties");
-                    if (properties != null) {
-                        properties.set("type", context.getGeneratorConfig().createObjectNode()
-                            .put("const", pluginType.getName())
-                        );
+                    if (SUBTYPE_RESOLUTION_EXCLUSION_FOR_PLUGIN_SCHEMA.contains(declaredType.getErasedType())) {
+                        return null;
                     }
-                }
-            });
+
+                    return this.subtypeResolver(declaredType, typeContext);
+                });
         }
+
+        // Ensure that `type` is defined as a constant in JSON Schema.
+        // The `const` property is used by editors for auto-completion based on that schema.
+        builder.forTypesInGeneral().withTypeAttributeOverride((collectedTypeAttributes, scope, context) -> {
+            final Class<?> pluginType = scope.getType().getErasedType();
+            if (pluginType.getAnnotation(Plugin.class) != null) {
+                ObjectNode properties = (ObjectNode) collectedTypeAttributes.get("properties");
+                if (properties != null) {
+                    properties.set("type", context.getGeneratorConfig().createObjectNode()
+                        .put("const", pluginType.getName())
+                    );
+                }
+            }
+        });
     }
 
     private boolean isAssignableFromResolvedAsString(Class<?> declaredType) {
@@ -556,6 +582,16 @@ public class JsonSchemaGenerator {
                 .filter(Predicate.not(io.kestra.core.models.Plugin::isInternal))
                 .map(typeContext::resolve)
                 .toList();
+        } else if (AdditionalPlugin.class.isAssignableFrom(declaredType.getErasedType())) { // base type for addition plugin is not AdditionalPlugin but a subtype of AdditionalPlugin.
+            return getRegisteredPlugins()
+                .stream()
+                .flatMap(registeredPlugin -> registeredPlugin.getAdditionalPlugins().stream())
+                // for additional plugins, we have one subtype by type of additional plugins (for ex: embedding store for Langchain4J), so we need to filter on the correct subtype
+                .filter(cls -> declaredType.getErasedType().isAssignableFrom(cls))
+                .filter(cls -> cls != declaredType.getErasedType())
+                .filter(Predicate.not(io.kestra.core.models.Plugin::isInternal))
+                .map(typeContext::resolve)
+                .toList();
         } else if (declaredType.getErasedType() == Chart.class) {
             return getRegisteredPlugins()
                 .stream()
@@ -629,7 +665,7 @@ public class JsonSchemaGenerator {
         try {
             ObjectNode objectNode = generator.generateSchema(cls);
             replaceAnyOfWithOneOf(objectNode);
-            pullOfDefaultFromOneOf(objectNode);
+            pullDocumentationAndDefaultFromOneOf(objectNode);
             removeRequiredOnPropsWithDefaults(objectNode);
 
             return JacksonMapper.toMap(extractMainRef(objectNode));

core/src/main/java/io/kestra/core/docs/Plugin.java

@@ -37,6 +37,7 @@ public class Plugin {
     private List<String> charts;
     private List<String> dataFilters;
     private List<String> logExporters;
+    private List<String> additionalPlugins;
     private List<PluginSubGroup.PluginCategory> categories;
     private String subGroup;
 
@@ -89,17 +90,18 @@ public class Plugin {
         plugin.subGroup = subgroup;
 
         Predicate<Class<?>> packagePredicate = c -> subgroup == null || c.getPackageName().equals(subgroup);
-        plugin.tasks = filterAndGetClassName(registeredPlugin.getTasks(), includeDeprecated, packagePredicate).stream().toList();
-        plugin.triggers = filterAndGetClassName(registeredPlugin.getTriggers(), includeDeprecated, packagePredicate).stream().toList();
-        plugin.conditions = filterAndGetClassName(registeredPlugin.getConditions(), includeDeprecated, packagePredicate).stream().toList();
-        plugin.storages = filterAndGetClassName(registeredPlugin.getStorages(), includeDeprecated, packagePredicate).stream().toList();
-        plugin.secrets = filterAndGetClassName(registeredPlugin.getSecrets(), includeDeprecated, packagePredicate).stream().toList();
-        plugin.taskRunners = filterAndGetClassName(registeredPlugin.getTaskRunners(), includeDeprecated, packagePredicate).stream().toList();
-        plugin.apps = filterAndGetClassName(registeredPlugin.getApps(), includeDeprecated, packagePredicate).stream().toList();
-        plugin.appBlocks = filterAndGetClassName(registeredPlugin.getAppBlocks(), includeDeprecated, packagePredicate).stream().toList();
-        plugin.charts = filterAndGetClassName(registeredPlugin.getCharts(), includeDeprecated, packagePredicate).stream().toList();
-        plugin.dataFilters = filterAndGetClassName(registeredPlugin.getDataFilters(), includeDeprecated, packagePredicate).stream().toList();
-        plugin.logExporters = filterAndGetClassName(registeredPlugin.getLogExporters(), includeDeprecated, packagePredicate).stream().toList();
+        plugin.tasks = filterAndGetClassName(registeredPlugin.getTasks(), includeDeprecated, packagePredicate);
+        plugin.triggers = filterAndGetClassName(registeredPlugin.getTriggers(), includeDeprecated, packagePredicate);
+        plugin.conditions = filterAndGetClassName(registeredPlugin.getConditions(), includeDeprecated, packagePredicate);
+        plugin.storages = filterAndGetClassName(registeredPlugin.getStorages(), includeDeprecated, packagePredicate);
+        plugin.secrets = filterAndGetClassName(registeredPlugin.getSecrets(), includeDeprecated, packagePredicate);
+        plugin.taskRunners = filterAndGetClassName(registeredPlugin.getTaskRunners(), includeDeprecated, packagePredicate);
+        plugin.apps = filterAndGetClassName(registeredPlugin.getApps(), includeDeprecated, packagePredicate);
+        plugin.appBlocks = filterAndGetClassName(registeredPlugin.getAppBlocks(), includeDeprecated, packagePredicate);
+        plugin.charts = filterAndGetClassName(registeredPlugin.getCharts(), includeDeprecated, packagePredicate);
+        plugin.dataFilters = filterAndGetClassName(registeredPlugin.getDataFilters(), includeDeprecated, packagePredicate);
+        plugin.logExporters = filterAndGetClassName(registeredPlugin.getLogExporters(), includeDeprecated, packagePredicate);
+        plugin.additionalPlugins = filterAndGetClassName(registeredPlugin.getAdditionalPlugins(), includeDeprecated, packagePredicate);
 
         return plugin;
     }

core/src/main/java/io/kestra/core/encryption/EncryptionService.java

@@ -64,8 +64,10 @@ public class EncryptionService {
      * The IV is recovered from the beginning of the string.
      *
      * @see #decrypt(String, byte[])
+     * @throws IllegalArgumentException when the cipherText cannot be BASE64 decoded.
+     *         This may indicate that the cipherText was not encrypted at first so a caller may use this as an indication as it tries to decode a text that was not encoded.
      */
-    public static String decrypt(String key, String cipherText) throws GeneralSecurityException {
+    public static String decrypt(String key, String cipherText) throws GeneralSecurityException, IllegalArgumentException {
         if (cipherText == null || cipherText.isEmpty()) {
             return cipherText;
         }

core/src/main/java/io/kestra/core/events/CrudEventType.java

@@ -8,6 +8,7 @@ public enum CrudEventType {
     LOGIN,
     LOGOUT,
     IMPERSONATE,
-    LOGIN_FAILURE
+    LOGIN_FAILURE,
+    ACCOUNT_LOCKED
 }
 

core/src/main/java/io/kestra/core/http/client/HttpClient.java

@@ -155,6 +155,14 @@ public class HttpClient implements Closeable {
             builder.addResponseInterceptorLast(new FailedResponseInterceptor());
         }
 
+        if (this.configuration.getAllowedResponseCodes() != null) {
+            List<Integer> list = runContext.render(this.configuration.getAllowedResponseCodes()).asList(Integer.class);
+
+            if (!list.isEmpty()) {
+                builder.addResponseInterceptorLast(new FailedResponseInterceptor(list));
+            }
+        }
+
         builder.addResponseInterceptorLast(new RunContextResponseInterceptor(this.runContext));
 
         // builder object
@@ -276,7 +284,7 @@ public class HttpClient implements Closeable {
         } else if (cls.isAssignableFrom(Byte[].class)) {
             return (T) ArrayUtils.toObject(EntityUtils.toByteArray(entity));
         } else {
-            return (T) JacksonMapper.ofJson().readValue(entity.getContent(), cls);
+            return (T) JacksonMapper.ofJson(false).readValue(entity.getContent(), cls);
         }
     }
 

core/src/main/java/io/kestra/core/http/client/apache/FailedResponseInterceptor.java

@@ -3,7 +3,6 @@ package io.kestra.core.http.client.apache;
 import io.kestra.core.http.HttpResponse;
 import io.kestra.core.http.HttpService;
 import io.kestra.core.http.client.HttpClientResponseException;
-import lombok.AllArgsConstructor;
 import org.apache.hc.core5.http.EntityDetails;
 import org.apache.hc.core5.http.HttpEntityContainer;
 import org.apache.hc.core5.http.HttpException;
@@ -12,22 +11,43 @@ import org.apache.hc.core5.http.protocol.HttpContext;
 
 import java.io.IOException;
 import java.nio.charset.StandardCharsets;
+import java.util.List;
 
-@AllArgsConstructor
 public class FailedResponseInterceptor implements HttpResponseInterceptor {
+    private final boolean allErrors;
+    private List<Integer> statusCodes;
+
+    public FailedResponseInterceptor() {
+        this.allErrors = true;
+    }
+
+    public FailedResponseInterceptor(List<Integer> statusCodes) {
+        this.statusCodes = statusCodes;
+        this.allErrors = false;
+    }
+
+
     @Override
     public void process(org.apache.hc.core5.http.HttpResponse response, EntityDetails entity, HttpContext context) throws HttpException, IOException {
-        if (response.getCode() >= 400) {
-            String error = "Failed http request with response code '" + response.getCode() + "'";
+        if (this.allErrors && response.getCode() >= 400) {
+            this.raiseError(response, context);
+        }
 
-            if (response instanceof HttpEntityContainer httpEntity && httpEntity.getEntity() != null) {
-                HttpService.HttpEntityCopy copy = HttpService.copy(httpEntity.getEntity());
-                httpEntity.setEntity(copy);
-
-                error += " and body:\n" + new String(copy.getBody(), StandardCharsets.UTF_8);
-            }
-
-            throw new HttpClientResponseException(error, HttpResponse.from(response, context));
+        if (this.statusCodes != null && !this.statusCodes.contains(response.getCode())) {
+            this.raiseError(response, context);
         }
     }
+
+    private void raiseError(org.apache.hc.core5.http.HttpResponse response, HttpContext context) throws IOException, HttpClientResponseException {
+        String error = "Failed http request with response code '" + response.getCode() + "'";
+
+        if (response instanceof HttpEntityContainer httpEntity && httpEntity.getEntity() != null) {
+            HttpService.HttpEntityCopy copy = HttpService.copy(httpEntity.getEntity());
+            httpEntity.setEntity(copy);
+
+            error += " and body:\n" + new String(copy.getBody(), StandardCharsets.UTF_8);
+        }
+
+        throw new HttpClientResponseException(error, HttpResponse.from(response, context));
+    }
 }

core/src/main/java/io/kestra/core/http/client/configurations/HttpConfiguration.java

@@ -13,6 +13,7 @@ import java.net.Proxy;
 import java.nio.charset.Charset;
 import java.nio.charset.StandardCharsets;
 import java.time.Duration;
+import java.util.List;
 
 @Builder(toBuilder = true)
 @Getter
@@ -42,6 +43,10 @@ public class HttpConfiguration {
     @Builder.Default
     private Property<Boolean> allowFailed = Property.of(false);
 
+    @Setter
+    @Schema(title = "List of response code allowed for this request")
+    private Property<List<Integer>> allowedResponseCodes;
+
     @Schema(title = "The default charset for the request.")
     @Builder.Default
     private final Property<Charset> defaultCharset = Property.of(StandardCharsets.UTF_8);

core/src/main/java/io/kestra/core/metrics/GlobalTagsConfigurer.java

@@ -1,11 +1,14 @@
 package io.kestra.core.metrics;
 
+import io.kestra.core.models.ServerType;
 import io.micrometer.core.instrument.simple.SimpleMeterRegistry;
 import io.micronaut.configuration.metrics.aggregator.MeterRegistryConfigurer;
 import io.micronaut.context.annotation.Requires;
 
-import java.util.stream.Collectors;
 import java.util.stream.Stream;
+
+import io.micronaut.context.annotation.Value;
+import io.micronaut.core.annotation.Nullable;
 import jakarta.inject.Inject;
 import jakarta.inject.Singleton;
 
@@ -15,20 +18,26 @@ public class GlobalTagsConfigurer implements MeterRegistryConfigurer<SimpleMeter
     @Inject
     MetricConfig metricConfig;
 
+    @Nullable
+    @Value("${kestra.server-type}")
+    ServerType serverType;
+
     @Override
     public void configure(SimpleMeterRegistry meterRegistry) {
-        if (metricConfig.getTags() != null) {
-            meterRegistry
-                .config()
-                .commonTags(
-                    metricConfig.getTags()
-                        .entrySet()
-                        .stream()
-                        .flatMap(e -> Stream.of(e.getKey(), e.getValue()))
-                        .toList()
-                        .toArray(String[]::new)
-                );
-        }
+        String[] tags = Stream
+            .concat(
+                metricConfig.getTags() != null ? metricConfig.getTags()
+                    .entrySet()
+                    .stream()
+                    .flatMap(e -> Stream.of(e.getKey(), e.getValue())) : Stream.empty(),
+                serverType != null ? Stream.of("server_type", serverType.name()) : Stream.empty()
+            )
+            .toList()
+            .toArray(String[]::new);
+
+        meterRegistry
+            .config()
+            .commonTags(tags);
     }
 
     @Override

core/src/main/java/io/kestra/core/models/Label.java

@@ -1,11 +1,10 @@
 package io.kestra.core.models;
 
 import io.kestra.core.utils.MapUtils;
+import jakarta.annotation.Nullable;
 import jakarta.validation.constraints.NotNull;
 
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 import java.util.stream.Collectors;
 
 public record Label(@NotNull String key, @NotNull String value) {
@@ -19,6 +18,7 @@ public record Label(@NotNull String key, @NotNull String value) {
     public static final String RESTARTED = SYSTEM_PREFIX + "restarted";
     public static final String REPLAY = SYSTEM_PREFIX + "replay";
     public static final String REPLAYED = SYSTEM_PREFIX + "replayed";
+    public static final String SIMULATED_EXECUTION = SYSTEM_PREFIX + "simulatedExecution";
 
     /**
      * Static helper method for converting a list of labels to a nested map.
@@ -27,11 +27,36 @@ public record Label(@NotNull String key, @NotNull String value) {
      * @return the nested {@link Map}.
      */
     public static Map<String, Object> toNestedMap(List<Label> labels) {
-        Map<String, Object> asMap = labels.stream()
+        return MapUtils.flattenToNestedMap(toMap(labels));
+    }
+
+    /**
+     * Static helper method for converting a list of labels to a flat map.
+     * Key order is kept.
+     *
+     * @param labels The list of {@link Label} to be converted.
+     * @return the flat {@link Map}.
+     */
+    public static Map<String, String> toMap(@Nullable List<Label> labels) {
+        if (labels == null || labels.isEmpty()) return Collections.emptyMap();
+        return labels.stream()
             .filter(label -> label.value() != null && label.key() != null)
-            // using an accumulator in case labels with the same key exists: the first is kept
-            .collect(Collectors.toMap(Label::key, Label::value, (first, second) -> first));
-        return MapUtils.flattenToNestedMap(asMap);
+            // using an accumulator in case labels with the same key exists: the second is kept
+            .collect(Collectors.toMap(Label::key, Label::value, (first, second) -> second, LinkedHashMap::new));
+    }
+
+    /**
+     * Static helper method for deduplicating a list of labels by their key.
+     * Value of the last key occurrence is kept.
+     *
+     * @param labels The list of {@link Label} to be deduplicated.
+     * @return the deduplicated {@link List}.
+     */
+    public static List<Label> deduplicate(@Nullable List<Label> labels) {
+        if (labels == null || labels.isEmpty()) return Collections.emptyList();
+        return toMap(labels).entrySet().stream()
+            .map(entry -> new Label(entry.getKey(), entry.getValue()))
+            .collect(Collectors.toCollection(ArrayList::new));
     }
 
     /**

core/src/main/java/io/kestra/core/models/PluginVersioning.java

@@ -10,7 +10,7 @@ import jakarta.validation.constraints.Pattern;
  */
 public interface PluginVersioning {
 
-    @Pattern(regexp="\\d+\\.\\d+\\.\\d+(-[a-zA-Z0-9]+)?|([a-zA-Z0-9]+)")
+    @Pattern(regexp="\\d+\\.\\d+\\.\\d+(-[a-zA-Z0-9-]+)?|([a-zA-Z0-9]+)")
     @Schema(title = "The version of the plugin to use.")
     String getVersion();
 }

core/src/main/java/io/kestra/core/models/QueryFilter.java

@@ -95,7 +95,7 @@ public record QueryFilter(
         NAMESPACE("namespace") {
             @Override
             public List<Op> supportedOp() {
-                return List.of(Op.EQUALS, Op.NOT_EQUALS, Op.CONTAINS, Op.STARTS_WITH, Op.ENDS_WITH, Op.REGEX);
+                return List.of(Op.EQUALS, Op.NOT_EQUALS, Op.CONTAINS, Op.STARTS_WITH, Op.ENDS_WITH, Op.REGEX, Op.IN);
             }
         },
         LABELS("labels") {
@@ -113,13 +113,13 @@ public record QueryFilter(
         START_DATE("startDate") {
             @Override
             public List<Op> supportedOp() {
-                return List.of(Op.GREATER_THAN, Op.LESS_THAN, Op.EQUALS, Op.NOT_EQUALS);
+                return List.of(Op.GREATER_THAN_OR_EQUAL_TO, Op.LESS_THAN_OR_EQUAL_TO, Op.GREATER_THAN, Op.LESS_THAN, Op.EQUALS, Op.NOT_EQUALS);
             }
         },
         END_DATE("endDate") {
             @Override
             public List<Op> supportedOp() {
-                return List.of(Op.GREATER_THAN, Op.LESS_THAN, Op.EQUALS, Op.NOT_EQUALS);
+                return List.of(Op.GREATER_THAN_OR_EQUAL_TO, Op.LESS_THAN_OR_EQUAL_TO, Op.GREATER_THAN, Op.LESS_THAN, Op.EQUALS, Op.NOT_EQUALS);
             }
         },
         STATE("state") {

core/src/main/java/io/kestra/core/models/executions/Execution.java

@@ -22,6 +22,7 @@ import io.kestra.core.serializers.ListOrMapOfLabelDeserializer;
 import io.kestra.core.serializers.ListOrMapOfLabelSerializer;
 import io.kestra.core.services.LabelService;
 import io.kestra.core.utils.IdUtils;
+import io.kestra.core.utils.ListUtils;
 import io.kestra.core.utils.MapUtils;
 import io.micronaut.core.annotation.Nullable;
 import io.swagger.v3.oas.annotations.Hidden;
@@ -123,7 +124,7 @@ public class Execution implements DeletedInterface, TenantInterface {
     }
 
     public List<Label> getLabels() {
-        return Optional.ofNullable(this.labels).orElse(new ArrayList<>());
+        return ListUtils.emptyOnNull(this.labels);
     }
 
     /**
@@ -147,6 +148,7 @@ public class Execution implements DeletedInterface, TenantInterface {
             .flowRevision(flow.getRevision())
             .state(new State())
             .scheduleDate(scheduleDate.map(ChronoZonedDateTime::toInstant).orElse(null))
+            .variables(flow.getVariables())
             .build();
 
         List<Label> executionLabels = new ArrayList<>(LabelService.labelsExcludingSystem(flow));
@@ -167,8 +169,22 @@ public class Execution implements DeletedInterface, TenantInterface {
     }
 
 
+    /**
+     * Customization of Lombok-generated builder.
+     */
     public static class ExecutionBuilder {
 
+        /**
+         * Enforce unique values of {@link Label} when using the builder.
+         *
+         * @param labels The labels.
+         * @return Deduplicated labels.
+         */
+        public ExecutionBuilder labels(List<Label> labels) {
+            this.labels = Label.deduplicate(labels);
+            return this;
+        }
+
         void prebuild() {
             this.originalId = this.id;
             this.metadata = ExecutionMetadata.builder()
@@ -214,7 +230,6 @@ public class Execution implements DeletedInterface, TenantInterface {
     }
 
     public Execution withLabels(List<Label> labels) {
-
         return new Execution(
             this.tenantId,
             this.id,
@@ -224,7 +239,7 @@ public class Execution implements DeletedInterface, TenantInterface {
             this.taskRunList,
             this.inputs,
             this.outputs,
-            labels,
+            Label.deduplicate(labels),
             this.variables,
             this.state,
             this.parentId,
@@ -348,7 +363,7 @@ public class Execution implements DeletedInterface, TenantInterface {
      *
      * @param resolvedTasks normal tasks
      * @param resolvedErrors errors tasks
-     * @param resolvedErrors finally tasks
+     * @param resolvedFinally finally tasks
      * @return the flow we need to follow
      */
     public List<ResolvedTask> findTaskDependingFlowState(

core/src/main/java/io/kestra/core/models/executions/ExecutionKilledExecution.java

@@ -2,7 +2,6 @@ package io.kestra.core.models.executions;
 
 import com.fasterxml.jackson.annotation.JsonInclude;
 import io.kestra.core.models.TenantInterface;
-import io.kestra.core.models.triggers.TriggerContext;
 import io.kestra.core.runners.WorkerTask;
 import jakarta.validation.constraints.NotNull;
 import lombok.*;
@@ -25,6 +24,11 @@ public class ExecutionKilledExecution extends ExecutionKilled implements TenantI
     @NotNull
     String executionId;
 
+    /**
+     * The state to move the execution to after kill.
+     */
+    io.kestra.core.models.flows.State.Type executionState;
+
     /**
      * Specifies whether killing the execution, also kill all sub-flow executions.
      */

core/src/main/java/io/kestra/core/models/executions/TaskRun.java

@@ -7,6 +7,7 @@ import io.kestra.core.models.tasks.ResolvedTask;
 import io.kestra.core.models.tasks.retrys.AbstractRetry;
 import io.kestra.core.utils.IdUtils;
 import io.swagger.v3.oas.annotations.Hidden;
+import jakarta.annotation.Nullable;
 import jakarta.validation.constraints.NotNull;
 import jakarta.validation.constraints.Pattern;
 import lombok.*;
@@ -62,6 +63,11 @@ public class TaskRun implements TenantInterface {
     @With
     Boolean dynamic;
 
+    // Set it to true to force execution even if the execution is killed
+    @Nullable
+    @With
+    Boolean forceExecution;
+
     @Deprecated
     public void setItems(String items) {
         // no-op for backward compatibility
@@ -81,7 +87,8 @@ public class TaskRun implements TenantInterface {
             this.outputs,
             this.state.withState(state),
             this.iteration,
-            this.dynamic
+            this.dynamic,
+            this.forceExecution
         );
     }
 
@@ -99,7 +106,8 @@ public class TaskRun implements TenantInterface {
             this.outputs,
             newState,
             this.iteration,
-            this.dynamic
+            this.dynamic,
+            this.forceExecution
         );
     }
 
@@ -121,7 +129,8 @@ public class TaskRun implements TenantInterface {
             this.outputs,
             this.state.withState(State.Type.FAILED),
             this.iteration,
-            this.dynamic
+            this.dynamic,
+            this.forceExecution
         );
     }
 

core/src/main/java/io/kestra/core/models/flows/Flow.java

@@ -248,19 +248,32 @@ public class Flow extends AbstractFlow implements HasUID {
             .toList();
     }
 
-    public List<Task> allErrorsWithChilds() {
+    public List<Task> allErrorsWithChildrend() {
         var allErrors = allTasksWithChilds().stream()
             .filter(task -> task.isFlowable() && ((FlowableTask<?>) task).getErrors() != null)
             .flatMap(task -> ((FlowableTask<?>) task).getErrors().stream())
             .collect(Collectors.toCollection(ArrayList::new));
 
-        if (this.getErrors() != null && !this.getErrors().isEmpty()) {
+        if (!ListUtils.isEmpty(this.getErrors())) {
             allErrors.addAll(this.getErrors());
         }
 
         return allErrors;
     }
 
+    public List<Task> allFinallyWithChildren() {
+        var allFinally = allTasksWithChilds().stream()
+            .filter(task -> task.isFlowable() && ((FlowableTask<?>) task).getFinally() != null)
+            .flatMap(task -> ((FlowableTask<?>) task).getFinally().stream())
+            .collect(Collectors.toCollection(ArrayList::new));
+
+        if (!ListUtils.isEmpty(this.getFinally())) {
+            allFinally.addAll(this.getFinally());
+        }
+
+        return allFinally;
+    }
+
     public Task findParentTasksByTaskId(String taskId) {
         return allTasksWithChilds()
             .stream()

core/src/main/java/io/kestra/core/models/flows/FlowWithPath.java

@@ -28,6 +28,7 @@ public class FlowWithPath {
     public static FlowWithPath of(FlowWithSource flow, String path) {
         return FlowWithPath.builder()
             .id(flow.getId())
+            .tenantId(flow.getTenantId())
             .namespace(flow.getNamespace())
             .path(path)
             .build();
@@ -36,6 +37,7 @@ public class FlowWithPath {
     public static FlowWithPath of(Flow flow, String path) {
         return FlowWithPath.builder()
             .id(flow.getId())
+            .tenantId(flow.getTenantId())
             .namespace(flow.getNamespace())
             .path(path)
             .build();

core/src/main/java/io/kestra/core/models/flows/input/MultiselectInput.java

@@ -108,7 +108,7 @@ public class MultiselectInput extends Input<List<String>> implements ItemTypeInt
     private List<String> renderExpressionValues(final Function<String, Object> renderer) {
         Object result;
         try {
-            result = renderer.apply(expression);
+            result = renderer.apply(expression.trim());
         } catch (Exception e) {
             throw ManualConstraintViolation.toConstraintViolationException(
                 "Cannot render 'expression'. Cause: " + e.getMessage(),

core/src/main/java/io/kestra/core/models/flows/input/SelectInput.java

@@ -86,7 +86,7 @@ public class SelectInput extends Input<String> implements RenderableInput {
     private List<String> renderExpressionValues(final Function<String, Object> renderer) {
         Object result;
         try {
-            result = renderer.apply(expression);
+            result = renderer.apply(expression.trim());
         } catch (Exception e) {
             throw ManualConstraintViolation.toConstraintViolationException(
                 "Cannot render 'expression'. Cause: " + e.getMessage(),

core/src/main/java/io/kestra/core/models/hierarchies/SubflowGraphTask.java

@@ -6,7 +6,7 @@ import io.kestra.core.models.executions.Execution;
 import io.kestra.core.models.executions.TaskRun;
 import io.kestra.core.models.flows.Flow;
 import io.kestra.core.models.tasks.*;
-import io.kestra.core.runners.FlowExecutorInterface;
+import io.kestra.core.runners.FlowMetaStoreInterface;
 import io.kestra.core.runners.RunContext;
 import io.kestra.core.runners.SubflowExecution;
 import io.kestra.core.runners.SubflowExecutionResult;
@@ -47,7 +47,7 @@ public class SubflowGraphTask extends AbstractGraphTask {
 
     public record SubflowTaskWrapper<T extends Output>(RunContext runContext, ExecutableTask<T> subflowTask) implements TaskInterface, ExecutableTask<T> {
         @Override
-        public List<SubflowExecution<?>> createSubflowExecutions(RunContext runContext, FlowExecutorInterface flowExecutorInterface, Flow currentFlow, Execution currentExecution, TaskRun currentTaskRun) throws InternalException {
+        public List<SubflowExecution<?>> createSubflowExecutions(RunContext runContext, FlowMetaStoreInterface flowExecutorInterface, Flow currentFlow, Execution currentExecution, TaskRun currentTaskRun) throws InternalException {
             return subflowTask.createSubflowExecutions(runContext, flowExecutorInterface, currentFlow, currentExecution, currentTaskRun);
         }
 

core/src/main/java/io/kestra/core/models/property/Property.java

@@ -8,9 +8,11 @@ import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
 import com.fasterxml.jackson.databind.annotation.JsonSerialize;
 import com.fasterxml.jackson.databind.deser.std.StdDeserializer;
 import com.fasterxml.jackson.databind.ser.std.StdSerializer;
+import com.google.common.annotations.VisibleForTesting;
 import io.kestra.core.exceptions.IllegalVariableEvaluationException;
 import io.kestra.core.runners.RunContext;
 import io.kestra.core.serializers.JacksonMapper;
+import jakarta.validation.constraints.NotNull;
 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
@@ -45,10 +47,16 @@ public class Property<T> {
     private String expression;
     private T value;
 
+    /**
+     * @deprecated use {@link #ofExpression(String)} instead.
+     */
+    @Deprecated
+    // Note: when not used, this constructor would not be deleted but made private so it can only be used by ofExpression(String) and the deserializer
     public Property(String expression) {
         this.expression = expression;
     }
 
+    @VisibleForTesting
     public Property(Map<?, ?> map) {
         try {
             expression = MAPPER.writeValueAsString(map);
@@ -65,8 +73,10 @@ public class Property<T> {
      * Build a new Property object with a value already set.<br>
      *
      * A property build with this method will always return the value passed at build time, no rendering will be done.
+     *
+     * Use {@link #ofExpression(String)} to build a property with a Pebble expression instead.
      */
-    public static <V> Property<V> of(V value) {
+    public static <V> Property<V> ofValue(V value) {
         // trick the serializer so the property would not be null at deserialization time
         String expression;
         if (value instanceof Map<?, ?> || value instanceof List<?>) {
@@ -93,6 +103,28 @@ public class Property<T> {
         return p;
     }
 
+    /**
+     * @deprecated use {@link #ofValue(Object)} instead.
+     */
+    @Deprecated
+    public static <V> Property<V> of(V value) {
+        return ofValue(value);
+    }
+
+    /**
+     * Build a new Property object with a Pebble expression.<br>
+     *
+     * Use {@link #ofValue(Object)} to build a property with a value instead.
+     */
+    public static <V> Property<V> ofExpression(@NotNull String expression) {
+        Objects.requireNonNull(expression, "'expression' is required");
+        if(!expression.contains("{")) {
+            throw new IllegalArgumentException("'expression' must be a valid Pebble expression");
+        }
+
+        return new Property<>(expression);
+    }
+
     /**
      * Render a property then convert it to its target type.<br>
      *

core/src/main/java/io/kestra/core/models/tasks/ExecutableTask.java

@@ -4,7 +4,7 @@ import io.kestra.core.exceptions.InternalException;
 import io.kestra.core.models.executions.Execution;
 import io.kestra.core.models.executions.TaskRun;
 import io.kestra.core.models.flows.Flow;
-import io.kestra.core.runners.FlowExecutorInterface;
+import io.kestra.core.runners.FlowMetaStoreInterface;
 import io.kestra.core.runners.RunContext;
 import io.kestra.core.runners.SubflowExecution;
 import io.kestra.core.runners.SubflowExecutionResult;
@@ -21,7 +21,7 @@ public interface ExecutableTask<T extends Output>{
      * Each SubflowExecution will generate a subflow execution.
      */
     List<SubflowExecution<?>> createSubflowExecutions(RunContext runContext,
-                                                      FlowExecutorInterface flowExecutorInterface,
+                                                      FlowMetaStoreInterface flowExecutorInterface,
                                                       Flow currentFlow, Execution currentExecution,
                                                       TaskRun currentTaskRun) throws InternalException;
 

core/src/main/java/io/kestra/core/models/tasks/NamespaceFiles.java

@@ -41,7 +41,8 @@ public class NamespaceFiles {
         title = "A list of namespaces in which searching files. The files are loaded in the namespace order, and only the latest version of a file is kept. Meaning if a file is present in the first and second namespace, only the file present on the second namespace will be loaded."
     )
     @Builder.Default
-    private Property<List<String>> namespaces = Property.of(List.of("{{flow.namespace}}"));
+    private Property<List<String>> namespaces = new Property<>("""
+        ["{{flow.namespace}}"]""");
 
     @Schema(
         title = "Comportment of the task if a file already exist in the working directory."

core/src/main/java/io/kestra/core/models/tasks/runners/ScriptService.java

@@ -30,7 +30,7 @@ import static io.kestra.core.utils.Rethrow.throwFunction;
  * Helper class for task runners and script tasks.
  */
 public final class ScriptService {
-    private static final Pattern INTERNAL_STORAGE_PATTERN = Pattern.compile("(kestra:\\/\\/[-a-zA-Z0-9%._\\+~#=/]*)");
+    private static final Pattern INTERNAL_STORAGE_PATTERN = Pattern.compile("(kestra:\\/\\/[-\\p{Alnum}._\\+~#=/]*)", Pattern.UNICODE_CHARACTER_CLASS);
 
     // These are the three common additional variables task runners must provide for variable rendering.
     public static final String VAR_WORKING_DIR = "workingDir";

core/src/main/java/io/kestra/core/plugins/AdditionalPlugin.java

@@ -0,0 +1,20 @@
+package io.kestra.core.plugins;
+
+import io.kestra.core.models.Plugin;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Pattern;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.experimental.SuperBuilder;
+
+@io.kestra.core.models.annotations.Plugin
+@SuperBuilder(toBuilder = true)
+@Getter
+@NoArgsConstructor
+public abstract class AdditionalPlugin implements Plugin {
+    @NotNull
+    @NotBlank
+    @Pattern(regexp="\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*(\\.\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*)*")
+    protected String type;
+}

core/src/main/java/io/kestra/core/plugins/LocalPluginManager.java

@@ -120,6 +120,7 @@ public class LocalPluginManager implements PluginManager {
                                   @Nullable Path localRepositoryPath) {
         Objects.requireNonNull(artifact, "cannot install null artifact");
 
+        log.info("Installing managed plugin artifact '{}'", artifact);
         final PluginArtifact resolvedPluginArtifact = mavenPluginDownloader.resolve(artifact.toString(), repositoryConfigs);
 
         return install(resolvedPluginArtifact, installForRegistration, localRepositoryPath);
@@ -129,7 +130,6 @@ public class LocalPluginManager implements PluginManager {
                                    final boolean installForRegistration,
                                    Path localRepositoryPath) {
 
-        log.info("Installing managed plugin artifact '{}'", artifact);
         localRepositoryPath = createLocalRepositoryIfNotExist(Optional.ofNullable(localRepositoryPath).orElse(this.localRepositoryPath));
         Path localPluginPath = getLocalPluginPath(localRepositoryPath, artifact);
 
@@ -153,7 +153,9 @@ public class LocalPluginManager implements PluginManager {
     @Override
     public PluginArtifact install(File file, boolean installForRegistration, @Nullable Path localRepositoryPath) {
         try {
-            return install(PluginArtifact.fromFile(file), installForRegistration, localRepositoryPath);
+            PluginArtifact artifact = PluginArtifact.fromFile(file);
+            log.info("Installing managed plugin artifact '{}'", artifact);
+            return install(artifact, installForRegistration, localRepositoryPath);
         } catch (IOException e) {
             throw new RuntimeException(e);
         }

core/src/main/java/io/kestra/core/plugins/MavenPluginDownloader.java

@@ -1,6 +1,7 @@
 package io.kestra.core.plugins;
 
 import io.kestra.core.contexts.MavenPluginRepositoryConfig;
+import io.kestra.core.exceptions.KestraRuntimeException;
 import io.kestra.core.utils.Version;
 import io.micronaut.context.annotation.Value;
 import io.micronaut.core.annotation.Nullable;
@@ -170,11 +171,11 @@ public class MavenPluginDownloader implements Closeable {
                     try {
                         FileUtils.deleteDirectory(new File(tmpDir));
                     } catch (IOException e) {
-                        throw new RuntimeException(e);
+                        throw new KestraRuntimeException(e);
                     }
                 }));
             } catch (IOException e) {
-                throw new RuntimeException(e);
+                throw new KestraRuntimeException(e);
             }
         }
 
@@ -207,7 +208,7 @@ public class MavenPluginDownloader implements Closeable {
                 result.getArtifact().getFile().toPath().toUri()
             );
         } catch (VersionRangeResolutionException | ArtifactResolutionException e) {
-            throw new RuntimeException("Failed to resolve dependency: '" + dependency + "'", e);
+            throw new KestraRuntimeException("Failed to resolve dependency: '" + dependency + "'", e);
         }
     }
 

core/src/main/java/io/kestra/core/plugins/PluginArtifact.java

@@ -38,7 +38,7 @@ public record PluginArtifact(
         "([^: ]+):([^: ]+)(:([^: ]*)(:([^: ]+))?)?:([^: ]+)"
     );
     private static final Pattern FILENAME_PATTERN = Pattern.compile(
-        "^(?<groupId>[\\w_]+)__(?<artifactId>[\\w-_]+)(?:__(?<classifier>[\\w-_]+))?__(?<version>\\d+_\\d+_\\d+(-[a-zA-Z0-9]+)?|([a-zA-Z0-9]+))\\.jar$"
+        "^(?<groupId>[\\w_]+)__(?<artifactId>[\\w-_]+)(?:__(?<classifier>[\\w-_]+))?__(?<version>\\d+_\\d+_\\d+(-[a-zA-Z0-9-]+)?|([a-zA-Z0-9]+))\\.jar$"
     );
 
     public static final String JAR_EXTENSION = "jar";

core/src/main/java/io/kestra/core/plugins/PluginCatalogService.java

@@ -15,7 +15,6 @@ import java.util.Base64;
 import java.util.Comparator;
 import java.util.List;
 import java.util.Map;
-import java.util.Objects;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.atomic.AtomicBoolean;
@@ -46,14 +45,14 @@ public class PluginCatalogService {
      *
      * @param httpClient    the HTTP Client to connect to Kestra API.
      * @param icons         specifies whether icons must be loaded for plugins.
-     * @param oss         specifies whether only OSS plugins must be returned.
+     * @param communityOnly specifies whether only OSS plugins must be returned.
      */
     public PluginCatalogService(final HttpClient httpClient,
                                 final boolean icons,
-                                final boolean oss) {
+                                final boolean communityOnly) {
         this.httpClient = httpClient;
         this.icons = icons;
-        this.oss = oss;
+        this.oss = communityOnly;
 
         // Immediately trigger an async load of plugin artifacts.
         this.isLoaded.set(true);

core/src/main/java/io/kestra/core/plugins/PluginClassLoader.java

@@ -34,6 +34,7 @@ public class PluginClassLoader extends URLClassLoader {
         + "|io.kestra.plugin.core"
         + "|org.slf4j"
         + "|ch.qos.logback"
+        + "|io.swagger"
         + "|com.fasterxml.jackson.core"
         + "|com.fasterxml.jackson.annotation"
         + "|com.fasterxml.jackson.module"
@@ -44,6 +45,7 @@ public class PluginClassLoader extends URLClassLoader {
         + "|org.reactivestreams"
         + "|dev.failsafe"
         + "|reactor"
+        + "|io.opentelemetry"
         + ")\\..*$");
 
     private final ClassLoader parent;

core/src/main/java/io/kestra/core/plugins/PluginScanner.java

@@ -110,6 +110,7 @@ public class PluginScanner {
         List<Class<? extends Chart<?>>> charts = new ArrayList<>();
         List<Class<? extends DataFilter<?, ?>>> dataFilters = new ArrayList<>();
         List<Class<? extends LogExporter<?>>> logExporter = new ArrayList<>();
+        List<Class<? extends AdditionalPlugin>> additionalPlugins = new ArrayList<>();
         List<String> guides = new ArrayList<>();
         Map<String, Class<?>> aliases = new HashMap<>();
 
@@ -172,6 +173,10 @@ public class PluginScanner {
                         log.debug("Loading LogExporter plugin: '{}'", plugin.getClass());
                         logExporter.add((Class<? extends LogExporter<?>>)  shipper.getClass());
                     }
+                    case AdditionalPlugin additionalPlugin -> {
+                        log.debug("Loading additional plugin: '{}'", plugin.getClass());
+                        additionalPlugins.add(additionalPlugin.getClass());
+                    }
                     default -> {
                     }
                 }
@@ -222,6 +227,7 @@ public class PluginScanner {
             .dataFilters(dataFilters)
             .guides(guides)
             .logExporters(logExporter)
+            .additionalPlugins(additionalPlugins)
             .aliases(aliases.entrySet().stream().collect(Collectors.toMap(
                 e -> e.getKey().toLowerCase(),
                 Function.identity()

core/src/main/java/io/kestra/core/plugins/RegisteredPlugin.java

@@ -45,8 +45,9 @@ public class RegisteredPlugin {
     private final List<Class<? extends AppBlockInterface>> appBlocks;
     private final List<Class<? extends Chart<?>>> charts;
     private final List<Class<? extends DataFilter<?, ?>>> dataFilters;
-    private final List<String> guides;
     private final List<Class<? extends LogExporter<?>>> logExporters;
+    private final List<Class<? extends AdditionalPlugin>> additionalPlugins;
+    private final List<String> guides;
     // Map<lowercasealias, <Alias, Class>>
     private final Map<String, Map.Entry<String, Class<?>>> aliases;
 
@@ -61,7 +62,8 @@ public class RegisteredPlugin {
             !appBlocks.isEmpty() ||
             !charts.isEmpty() ||
             !dataFilters.isEmpty() ||
-            !logExporters.isEmpty()
+            !logExporters.isEmpty() ||
+            !additionalPlugins.isEmpty()
         ;
     }
 
@@ -126,6 +128,10 @@ public class RegisteredPlugin {
             return LogExporter.class;
         }
 
+        if (this.getAdditionalPlugins().stream().anyMatch(r -> r.getName().equals(cls))) {
+            return AdditionalPlugin.class;
+        }
+
         if (this.getAliases().containsKey(cls.toLowerCase())) {
             // This is a quick-win, but it may trigger an infinite loop ... or not ...
             return baseClass(this.getAliases().get(cls.toLowerCase()).getValue().getName());
@@ -158,14 +164,11 @@ public class RegisteredPlugin {
         result.put("charts", Arrays.asList(this.getCharts().toArray(Class[]::new)));
         result.put("data-filters", Arrays.asList(this.getDataFilters().toArray(Class[]::new)));
         result.put("log-exporters", Arrays.asList(this.getLogExporters().toArray(Class[]::new)));
+        result.put("additional-plugins", Arrays.asList(this.getAdditionalPlugins().toArray(Class[]::new)));
 
         return result;
     }
 
-//    public Map<String, Map<String,List<Class>>> allClassGroupedBySubGroup() {
-//
-//    }
-
     public Set<String> subGroupNames() {
         return allClass()
             .stream()
@@ -360,6 +363,12 @@ public class RegisteredPlugin {
             b.append("] ");
         }
 
+        if (!this.getAdditionalPlugins().isEmpty()) {
+            b.append("[Additional Plugins: ");
+            b.append(this.getAdditionalPlugins().stream().map(Class::getName).collect(Collectors.joining(", ")));
+            b.append("] ");
+        }
+
         if (!this.getAliases().isEmpty()) {
             b.append("[Aliases: ");
             b.append(this.getAliases().values().stream().collect(Collectors.toMap(

core/src/main/java/io/kestra/core/repositories/ExecutionRepositoryInterface.java

@@ -94,6 +94,7 @@ public interface ExecutionRepositoryInterface extends SaveRepositoryInterface<Ex
         boolean allowDeleted
     );
 
+    Flux<Execution> findAllAsync(@Nullable String tenantId);
 
     ArrayListTotal<TaskRun> findTaskRun(
         Pageable pageable,

core/src/main/java/io/kestra/core/repositories/LogRepositoryInterface.java

@@ -88,6 +88,8 @@ public interface LogRepositoryInterface extends SaveRepositoryInterface<LogEntry
         ZonedDateTime startDate
     );
 
+    Flux<LogEntry> findAllAsync(@Nullable String tenantId);
+
     List<LogStatistics> statistics(
         @Nullable String query,
         @Nullable String tenantId,

core/src/main/java/io/kestra/core/repositories/MetricRepositoryInterface.java

@@ -6,6 +6,7 @@ import io.kestra.core.models.executions.metrics.MetricAggregations;
 import io.kestra.plugin.core.dashboard.data.Metrics;
 import io.micronaut.core.annotation.Nullable;
 import io.micronaut.data.model.Pageable;
+import reactor.core.publisher.Flux;
 
 import java.time.ZonedDateTime;
 import java.util.List;
@@ -28,6 +29,8 @@ public interface MetricRepositoryInterface extends SaveRepositoryInterface<Metri
 
     Integer purge(Execution execution);
 
+    Flux<MetricEntry> findAllAsync(@Nullable String tenantId);
+
     default Function<String, String> sortMapping() throws IllegalArgumentException {
         return s -> s;
     }

core/src/main/java/io/kestra/core/runners/AbstractWorkerCallable.java

@@ -2,6 +2,7 @@ package io.kestra.core.runners;
 
 import io.kestra.core.models.WorkerJobLifecycle;
 import io.kestra.core.models.flows.State;
+import io.kestra.core.utils.Exceptions;
 import io.opentelemetry.api.trace.Span;
 import io.opentelemetry.api.trace.StatusCode;
 import lombok.Getter;
@@ -61,6 +62,7 @@ public abstract class AbstractWorkerCallable implements Callable<State.Type> {
         try {
             return doCall();
         } catch (Throwable e) {
+            Exceptions.throwIfFatal(e);
             // Catching Throwable is usually a bad idea.
             // However, here, we want to be sure that the task fails whatever happens,
             // and some plugins may throw errors, for example, for dependency issues or worst,

core/src/main/java/io/kestra/core/runners/DefaultFlowMetaStore.java

@@ -12,13 +12,13 @@ import java.util.List;
 import java.util.Optional;
 
 @Singleton
-public class DefaultFlowExecutor implements FlowExecutorInterface {
+public class DefaultFlowMetaStore implements FlowMetaStoreInterface {
     private final FlowRepositoryInterface flowRepository;
 
     @Setter
     private List<FlowWithSource> allFlows;
 
-    public DefaultFlowExecutor(FlowListenersInterface flowListeners, FlowRepositoryInterface flowRepository) {
+    public DefaultFlowMetaStore(FlowListenersInterface flowListeners, FlowRepositoryInterface flowRepository) {
         this.flowRepository = flowRepository;
 
         flowListeners.listen(flows -> this.allFlows = flows);

core/src/main/java/io/kestra/core/runners/DefaultRunContext.java

@@ -15,6 +15,7 @@ import io.kestra.core.storages.Storage;
 import io.kestra.core.storages.StorageInterface;
 import io.kestra.core.storages.kv.KVStore;
 import io.kestra.core.utils.ListUtils;
+import io.kestra.core.utils.MapUtils;
 import io.kestra.core.utils.VersionProvider;
 import io.micronaut.context.ApplicationContext;
 import io.micronaut.core.annotation.Introspected;
@@ -172,7 +173,7 @@ public class DefaultRunContext extends RunContext {
             @SuppressWarnings("unchecked")
             Map<String, Object> inputs = (Map<String, Object>) getVariables().get("inputs");
             for (String secretInput : secretInputs) {
-                String secret = (String) inputs.get(secretInput);
+                String secret = findSecret(secretInput, inputs);
                 if (secret != null) {
                     logger.usedSecret(secret);
                 }
@@ -180,6 +181,18 @@ public class DefaultRunContext extends RunContext {
         }
     }
 
+    @SuppressWarnings("unchecked")
+    private String findSecret(String secretInput, Map<String, Object> inputs) {
+        if (secretInput.indexOf('.') > 0) {
+            String prefix = secretInput.substring(0, secretInput.indexOf('.'));
+            String suffix = secretInput.substring(secretInput.indexOf('.') + 1);
+            Map<String, Object> subInputs = (Map<String, Object>) inputs.get(prefix);
+            return findSecret(suffix, subInputs);
+        }
+
+        return (String) inputs.get(secretInput);
+    }
+
     void setPluginConfiguration(final Map<String, Object> pluginConfiguration) {
         this.pluginConfiguration = pluginConfiguration;
     }

core/src/main/java/io/kestra/core/runners/ExecutableUtils.java

@@ -4,7 +4,10 @@ import com.google.common.collect.ImmutableMap;
 import io.kestra.core.exceptions.IllegalVariableEvaluationException;
 import io.kestra.core.exceptions.InternalException;
 import io.kestra.core.models.Label;
-import io.kestra.core.models.executions.*;
+import io.kestra.core.models.executions.Execution;
+import io.kestra.core.models.executions.ExecutionTrigger;
+import io.kestra.core.models.executions.TaskRun;
+import io.kestra.core.models.executions.TaskRunAttempt;
 import io.kestra.core.models.flows.Flow;
 import io.kestra.core.models.flows.FlowWithException;
 import io.kestra.core.models.flows.State;
@@ -15,9 +18,9 @@ import io.kestra.core.repositories.ExecutionRepositoryInterface;
 import io.kestra.core.services.ExecutionService;
 import io.kestra.core.storages.Storage;
 import io.kestra.core.trace.TracerFactory;
+import io.kestra.core.trace.propagation.ExecutionTextMapSetter;
 import io.kestra.core.utils.ListUtils;
 import io.kestra.core.utils.MapUtils;
-import io.kestra.core.trace.propagation.ExecutionTextMapSetter;
 import io.opentelemetry.api.OpenTelemetry;
 import io.opentelemetry.context.Context;
 import io.opentelemetry.context.propagation.ContextPropagators;
@@ -66,7 +69,7 @@ public final class ExecutableUtils {
 
     public static <T extends Task & ExecutableTask<?>> Optional<SubflowExecution<?>> subflowExecution(
         RunContext runContext,
-        FlowExecutorInterface flowExecutorInterface,
+        FlowMetaStoreInterface flowExecutorInterface,
         Execution currentExecution,
         Flow currentFlow,
         T currentTask,
@@ -90,126 +93,130 @@ public final class ExecutableUtils {
             currentExecution,
             currentTask.getType(),
             throwCallable(() -> {
-            // If we are in a flow that is restarted, we search for existing run of the task to restart them
-            if (currentExecution.getLabels() != null && currentExecution.getLabels().contains(new Label(Label.RESTARTED, "true"))
-                && currentTask.getRestartBehavior() == ExecutableTask.RestartBehavior.RETRY_FAILED) {
-                ExecutionRepositoryInterface executionRepository = ((DefaultRunContext) runContext).getApplicationContext().getBean(ExecutionRepositoryInterface.class);
+                // If we are in a flow that is restarted, we search for existing run of the task to restart them
+                if (currentExecution.getLabels() != null && currentExecution.getLabels().contains(new Label(Label.RESTARTED, "true"))
+                    && currentTask.getRestartBehavior() == ExecutableTask.RestartBehavior.RETRY_FAILED) {
+                    ExecutionRepositoryInterface executionRepository = ((DefaultRunContext) runContext).getApplicationContext().getBean(ExecutionRepositoryInterface.class);
 
-                Optional<Execution> existingSubflowExecution = Optional.empty();
-                if (currentTaskRun.getOutputs() != null && currentTaskRun.getOutputs().containsKey("executionId")) {
-                    // we know which execution to restart; this should be the case for Subflow tasks
-                    existingSubflowExecution = executionRepository.findById(currentExecution.getTenantId(), (String) currentTaskRun.getOutputs().get("executionId"));
-                }
+                    Optional<Execution> existingSubflowExecution = Optional.empty();
+                    if (currentTaskRun.getOutputs() != null && currentTaskRun.getOutputs().containsKey("executionId")) {
+                        // we know which execution to restart; this should be the case for Subflow tasks
+                        existingSubflowExecution = executionRepository.findById(currentExecution.getTenantId(), (String) currentTaskRun.getOutputs().get("executionId"));
+                    }
 
-                if (existingSubflowExecution.isEmpty()) {
-                    // otherwise, we try to find the correct one; this should be the case for ForEachItem tasks
-                    List<Execution> childExecutions = executionRepository.findAllByTriggerExecutionId(currentExecution.getTenantId(), currentExecution.getId())
-                        .filter(e -> e.getNamespace().equals(currentTask.subflowId().namespace()) && e.getFlowId().equals(currentTask.subflowId().flowId()) && e.getTrigger().getId().equals(currentTask.getId()))
-                        .filter(e -> Objects.equals(e.getTrigger().getVariables().get("taskRunId"), currentTaskRun.getId()) && Objects.equals(e.getTrigger().getVariables().get("taskRunValue"), currentTaskRun.getValue()) && Objects.equals(e.getTrigger().getVariables().get("taskRunIteration"), currentTaskRun.getIteration()))
-                        .collectList()
-                        .block();
+                    if (existingSubflowExecution.isEmpty()) {
+                        // otherwise, we try to find the correct one; this should be the case for ForEachItem tasks
+                        List<Execution> childExecutions = executionRepository.findAllByTriggerExecutionId(currentExecution.getTenantId(), currentExecution.getId())
+                            .filter(e -> e.getNamespace().equals(currentTask.subflowId().namespace()) && e.getFlowId().equals(currentTask.subflowId().flowId()) && e.getTrigger().getId().equals(currentTask.getId()))
+                            .filter(e -> Objects.equals(e.getTrigger().getVariables().get("taskRunId"), currentTaskRun.getId()) && Objects.equals(e.getTrigger().getVariables().get("taskRunValue"), currentTaskRun.getValue()) && Objects.equals(e.getTrigger().getVariables().get("taskRunIteration"), currentTaskRun.getIteration()))
+                            .collectList()
+                            .block();
 
-                    if (childExecutions != null && childExecutions.size() == 1) {
-                        // if there are more than one, we ignore the results and create a new one
-                        existingSubflowExecution = Optional.of(childExecutions.getFirst());
+                        if (childExecutions != null && childExecutions.size() == 1) {
+                            // if there are more than one, we ignore the results and create a new one
+                            existingSubflowExecution = Optional.of(childExecutions.getFirst());
+                        }
+                    }
+
+                    if (existingSubflowExecution.isPresent()) {
+                        Execution subflowExecution = existingSubflowExecution.get();
+                        if (!subflowExecution.getState().isFailed()) {
+                            // don't restart it as it's terminated successfully
+                            return Optional.empty();
+                        }
+                        ExecutionService executionService = ((DefaultRunContext) runContext).getApplicationContext().getBean(ExecutionService.class);
+                        try {
+                            Execution restarted = executionService.restart(subflowExecution, null);
+
+                            // inject the traceparent into the new execution
+                            propagator.ifPresent(pg -> pg.inject(Context.current(), restarted, ExecutionTextMapSetter.INSTANCE));
+
+                            return Optional.of(SubflowExecution.builder()
+                                .parentTask(currentTask)
+                                .parentTaskRun(currentTaskRun.withState(State.Type.RUNNING))
+                                .execution(restarted)
+                                .build());
+                        } catch (Exception e) {
+                            throw new RuntimeException(e);
+                        }
                     }
                 }
 
-                if (existingSubflowExecution.isPresent()) {
-                    Execution subflowExecution = existingSubflowExecution.get();
-                    if (!subflowExecution.getState().isFailed()) {
-                        // don't restart it as it's terminated successfully
-                        return Optional.empty();
-                    }
-                    ExecutionService executionService = ((DefaultRunContext) runContext).getApplicationContext().getBean(ExecutionService.class);
-                    try {
-                        Execution restarted = executionService.restart(subflowExecution, null);
+                String subflowNamespace = runContext.render(currentTask.subflowId().namespace());
+                String subflowId = runContext.render(currentTask.subflowId().flowId());
+                Optional<Integer> subflowRevision = currentTask.subflowId().revision();
 
-                        // inject the traceparent into the new execution
-                        propagator.ifPresent(pg -> pg.inject(Context.current(), restarted, ExecutionTextMapSetter.INSTANCE));
+                Flow flow = flowExecutorInterface.findByIdFromTask(
+                        currentExecution.getTenantId(),
+                        subflowNamespace,
+                        subflowId,
+                        subflowRevision,
+                        currentExecution.getTenantId(),
+                        currentFlow.getNamespace(),
+                        currentFlow.getId()
+                    )
+                    .orElseThrow(() -> new IllegalStateException("Unable to find flow '" + subflowNamespace + "'.'" + subflowId + "' with revision '" + subflowRevision.orElse(0) + "'"));
 
-                        return Optional.of(SubflowExecution.builder()
-                            .parentTask(currentTask)
-                            .parentTaskRun(currentTaskRun.withState(State.Type.RUNNING))
-                            .execution(restarted)
-                            .build());
-                    } catch (Exception e) {
-                        throw new RuntimeException(e);
-                    }
+                if (flow.isDisabled()) {
+                    throw new IllegalStateException("Cannot execute a flow which is disabled");
                 }
-            }
 
-            String subflowNamespace = runContext.render(currentTask.subflowId().namespace());
-            String subflowId = runContext.render(currentTask.subflowId().flowId());
-            Optional<Integer> subflowRevision = currentTask.subflowId().revision();
+                if (flow instanceof FlowWithException fwe) {
+                    throw new IllegalStateException("Cannot execute an invalid flow: " + fwe.getException());
+                }
 
-            Flow flow = flowExecutorInterface.findByIdFromTask(
-                    currentExecution.getTenantId(),
-                    subflowNamespace,
-                    subflowId,
-                    subflowRevision,
-                    currentExecution.getTenantId(),
-                    currentFlow.getNamespace(),
-                    currentFlow.getId()
-                )
-                .orElseThrow(() -> new IllegalStateException("Unable to find flow '" + subflowNamespace + "'.'" + subflowId + "' with revision '" + subflowRevision.orElse(0) + "'"));
+                List<Label> newLabels = inheritLabels ? new ArrayList<>(filterLabels(currentExecution.getLabels(), flow)) : new ArrayList<>(systemLabels(currentExecution));
+                if (labels != null) {
+                    labels.forEach(throwConsumer(label -> {
+                        String renderedKey = runContext.render(label.key());
+                        newLabels.removeIf(l -> l.key().equals(renderedKey));
+                        newLabels.add(new Label(renderedKey, runContext.render(label.value())));
+                    }));
+                }
 
-            if (flow.isDisabled()) {
-                throw new IllegalStateException("Cannot execute a flow which is disabled");
-            }
+                var variables = ImmutableMap.<String, Object>builder().putAll(Map.of(
+                    "executionId", currentExecution.getId(),
+                    "namespace", currentFlow.getNamespace(),
+                    "flowId", currentFlow.getId(),
+                    "flowRevision", currentFlow.getRevision(),
+                    "taskRunId", currentTaskRun.getId(),
+                    "taskId", currentTaskRun.getTaskId()
+                ));
+                if (currentTaskRun.getOutputs() != null) {
+                    variables.put("taskRunOutputs", currentTaskRun.getOutputs());
+                }
+                if (currentTaskRun.getValue() != null) {
+                    variables.put("taskRunValue", currentTaskRun.getValue());
+                }
+                if (currentTaskRun.getIteration() != null) {
+                    variables.put("taskRunIteration", currentTaskRun.getIteration());
+                }
 
-            if (flow instanceof FlowWithException fwe) {
-                throw new IllegalStateException("Cannot execute an invalid flow: " + fwe.getException());
-            }
+                FlowInputOutput flowInputOutput = ((DefaultRunContext) runContext).getApplicationContext().getBean(FlowInputOutput.class);
+                Instant scheduleOnDate = runContext.render(scheduleDate).as(ZonedDateTime.class).map(date -> date.toInstant()).orElse(null);
+                Execution execution = Execution
+                    .newExecution(
+                        flow,
+                        (f, e) -> flowInputOutput.readExecutionInputs(f, e, inputs),
+                        newLabels,
+                        Optional.empty())
+                    .withTrigger(ExecutionTrigger.builder()
+                        .id(currentTask.getId())
+                        .type(currentTask.getType())
+                        .variables(variables.build())
+                        .build()
+                    )
+                    .withScheduleDate(scheduleOnDate);
 
-            List<Label> newLabels = inheritLabels ? new ArrayList<>(filterLabels(currentExecution.getLabels(), flow)) : new ArrayList<>(systemLabels(currentExecution));
-            if (labels != null) {
-                labels.forEach(throwConsumer(label -> newLabels.add(new Label(runContext.render(label.key()), runContext.render(label.value())))));
-            }
+                // inject the traceparent into the new execution
+                propagator.ifPresent(pg -> pg.inject(Context.current(), execution, ExecutionTextMapSetter.INSTANCE));
 
-            var variables = ImmutableMap.<String, Object>builder().putAll(Map.of(
-                "executionId", currentExecution.getId(),
-                "namespace", currentFlow.getNamespace(),
-                "flowId", currentFlow.getId(),
-                "flowRevision", currentFlow.getRevision(),
-                "taskRunId", currentTaskRun.getId(),
-                "taskId", currentTaskRun.getTaskId()
-            ));
-            if (currentTaskRun.getOutputs() != null) {
-                variables.put("taskRunOutputs", currentTaskRun.getOutputs());
-            }
-            if (currentTaskRun.getValue() != null) {
-                variables.put("taskRunValue", currentTaskRun.getValue());
-            }
-            if (currentTaskRun.getIteration() != null) {
-                variables.put("taskRunIteration", currentTaskRun.getIteration());
-            }
-
-            FlowInputOutput flowInputOutput = ((DefaultRunContext)runContext).getApplicationContext().getBean(FlowInputOutput.class);
-            Instant scheduleOnDate = runContext.render(scheduleDate).as(ZonedDateTime.class).map(date -> date.toInstant()).orElse(null);
-            Execution execution = Execution
-                .newExecution(
-                    flow,
-                    (f, e) -> flowInputOutput.readExecutionInputs(f, e, inputs),
-                    newLabels,
-                    Optional.empty())
-                .withTrigger(ExecutionTrigger.builder()
-                    .id(currentTask.getId())
-                    .type(currentTask.getType())
-                    .variables(variables.build())
-                    .build()
-                )
-                .withScheduleDate(scheduleOnDate);
-
-            // inject the traceparent into the new execution
-            propagator.ifPresent(pg -> pg.inject(Context.current(), execution, ExecutionTextMapSetter.INSTANCE));
-
-            return Optional.of(SubflowExecution.builder()
-                .parentTask(currentTask)
-                .parentTaskRun(currentTaskRun.withState(State.Type.RUNNING))
-                .execution(execution)
-                .build());
-        }));
+                return Optional.of(SubflowExecution.builder()
+                    .parentTask(currentTask)
+                    .parentTaskRun(currentTaskRun.withState(State.Type.RUNNING))
+                    .execution(execution)
+                    .build());
+            }));
     }
 
     private static List<Label> filterLabels(List<Label> labels, Flow flow) {

core/src/main/java/io/kestra/core/runners/ExecutorService.java

@@ -18,9 +18,9 @@ import io.kestra.core.services.*;
 import io.kestra.core.trace.propagation.RunContextTextMapSetter;
 import io.kestra.core.utils.ListUtils;
 import io.kestra.core.utils.TruthUtils;
+import io.kestra.plugin.core.flow.LoopUntil;
 import io.kestra.plugin.core.flow.Pause;
 import io.kestra.plugin.core.flow.Subflow;
-import io.kestra.plugin.core.flow.LoopUntil;
 import io.kestra.plugin.core.flow.WorkingDirectory;
 import io.micronaut.context.ApplicationContext;
 import io.opentelemetry.api.OpenTelemetry;
@@ -65,7 +65,10 @@ public class ExecutorService {
     @Inject
     private WorkerGroupExecutorInterface workerGroupExecutorInterface;
 
-    protected FlowExecutorInterface flowExecutorInterface;
+    protected FlowMetaStoreInterface flowExecutorInterface;
+
+    @Inject
+    private WorkerJobRunningStateStore workerJobRunningStateStore;
 
     @Inject
     private ExecutionService executionService;
@@ -83,10 +86,10 @@ public class ExecutorService {
     @Named(QueueFactoryInterface.KILL_NAMED)
     protected QueueInterface<ExecutionKilled> killQueue;
 
-    protected FlowExecutorInterface flowExecutorInterface() {
+    protected FlowMetaStoreInterface flowExecutorInterface() {
         // bean is injected late, so we need to wait
         if (this.flowExecutorInterface == null) {
-            this.flowExecutorInterface = applicationContext.getBean(FlowExecutorInterface.class);
+            this.flowExecutorInterface = applicationContext.getBean(FlowMetaStoreInterface.class);
         }
 
         return this.flowExecutorInterface;
@@ -541,7 +544,8 @@ public class ExecutorService {
                     // Prevent workerTaskResult of flowable to be sent
                     // because one of its children is retrying
                     if (taskRun.getParentTaskRunId() != null) {
-                        list = list.stream().filter(workerTaskResult -> !workerTaskResult.getTaskRun().getId().equals(taskRun.getParentTaskRunId())).toList();
+                        list = list.stream().filter(workerTaskResult -> !workerTaskResult.getTaskRun().getId().equals(taskRun.getParentTaskRunId()))
+                            .collect(Collectors.toCollection(ArrayList::new));
                     }
                 }
             }
@@ -574,7 +578,8 @@ public class ExecutorService {
             // If the task is retrying
             // make sure that the workerTaskResult of the parent task is not sent
             if (taskRun.getState().isRetrying() && taskRun.getParentTaskRunId() != null) {
-                list = list.stream().filter(workerTaskResult -> !workerTaskResult.getTaskRun().getId().equals(taskRun.getParentTaskRunId())).toList();
+                list = list.stream().filter(workerTaskResult -> !workerTaskResult.getTaskRun().getId().equals(taskRun.getParentTaskRunId()))
+                    .collect(Collectors.toCollection(ArrayList::new));
             }
         }
 
@@ -702,6 +707,7 @@ public class ExecutorService {
         List<TaskRun> afterExecutionNexts = FlowableUtils.resolveSequentialNexts(executor.getExecution(), afterExecutionResolvedTasks)
             .stream()
             .map(throwFunction(NextTaskRun::getTaskRun))
+            .map(taskRun -> taskRun.withForceExecution(true)) // forceExecution so it would be executed even if the execution is killed
             .toList();
         if (!afterExecutionNexts.isEmpty()) {
             return executor.withTaskRun(afterExecutionNexts, "handleAfterExecution ");
@@ -1011,6 +1017,17 @@ public class ExecutorService {
             newExecution = executionService.killParentTaskruns(taskRun, newExecution);
         }
         executor.withExecution(newExecution, "addWorkerTaskResult");
+        if (taskRun.getState().isTerminated()) {
+            log.trace("TaskRun terminated: {}", taskRun);
+            workerJobRunningStateStore.deleteByKey(taskRun.getId());
+            metricRegistry
+                .counter(MetricRegistry.EXECUTOR_TASKRUN_ENDED_COUNT, metricRegistry.tags(workerTaskResult))
+                .increment();
+
+            metricRegistry
+                .timer(MetricRegistry.EXECUTOR_TASKRUN_ENDED_DURATION, metricRegistry.tags(workerTaskResult))
+                .record(taskRun.getState().getDuration());
+        }
     }
 
     private Execution addDynamicTaskRun(Execution execution, Flow flow, WorkerTaskResult workerTaskResult) throws InternalException {
@@ -1206,6 +1223,7 @@ public class ExecutorService {
         killQueue.emit(ExecutionKilledExecution
             .builder()
             .state(ExecutionKilled.State.REQUESTED)
+            .executionState(state)
             .executionId(execution.getId())
             .isOnKillCascade(false) // TODO we may offer the choice to the user here
             .tenantId(execution.getTenantId())

core/src/main/java/io/kestra/core/runners/FlowMetaStoreInterface.java

@@ -7,7 +7,7 @@ import io.kestra.core.models.flows.FlowWithSource;
 import java.util.Collection;
 import java.util.Optional;
 
-public interface FlowExecutorInterface {
+public interface FlowMetaStoreInterface {
     /**
      * Find all flows.
      * WARNING: this method will NOT check if the namespace is allowed, so it should not be used inside a task.

core/src/main/java/io/kestra/core/runners/FlowableUtils.java

@@ -265,14 +265,19 @@ public class FlowableUtils {
             return Collections.emptyList();
         }
 
-        long concurrencySlots = concurrency == 0 ? Integer.MAX_VALUE : concurrency - nonTerminatedCount;
+        Map<String, List<ResolvedTask>> collect = allTasks
+            .stream()
+            .collect(Collectors.groupingBy(ResolvedTask::getValue, LinkedHashMap::new, Collectors.toList()));
+
+        long resolvedConcurrency = concurrency == 0 ? Integer.MAX_VALUE : concurrency;
+        // if concurrencyLimit > values.size() we limit concurrency to values.size()
+        if (resolvedConcurrency > collect.size()) {
+            resolvedConcurrency = collect.size();
+        }
+        long concurrencySlots = resolvedConcurrency - nonTerminatedCount;
 
         // first one
         if (taskRuns.isEmpty()) {
-            Map<String, List<ResolvedTask>> collect = allTasks
-                .stream()
-                .collect(Collectors.groupingBy(ResolvedTask::getValue, LinkedHashMap::new, Collectors.toList()));
-
             return collect.values().stream()
                 .limit(concurrencySlots)
                 .map(resolvedTasks -> resolvedTasks.getFirst().toNextTaskRun(execution))
@@ -281,23 +286,11 @@ public class FlowableUtils {
         }
 
         // start as many tasks as we have concurrency slots
-        Map<String, List<ResolvedTask>> collect = allTasks
-            .stream()
-            .collect(Collectors.groupingBy(ResolvedTask::getValue, LinkedHashMap::new, Collectors.toList()));
-
         return collect.values().stream()
-            .map(resolvedTasks -> filterCreated(resolvedTasks, taskRuns, parentTaskRun))
+            .map(resolvedTasks -> resolveSequentialNexts(execution, resolvedTasks, null, null, parentTaskRun))
             .filter(resolvedTasks -> !resolvedTasks.isEmpty())
             .limit(concurrencySlots)
-            .map(resolvedTasks -> resolvedTasks.getFirst().toNextTaskRun(execution))
-            .toList();
-    }
-
-    private static List<ResolvedTask> filterCreated(List<ResolvedTask> tasks, List<TaskRun> taskRuns, TaskRun parentTaskRun) {
-        return tasks.stream()
-            .filter(resolvedTask -> taskRuns.stream()
-                .noneMatch(taskRun -> FlowableUtils.isTaskRunFor(resolvedTask, taskRun, parentTaskRun))
-            )
+            .map(resolvedTasks -> resolvedTasks.getFirst())
             .toList();
     }
 

core/src/main/java/io/kestra/core/runners/RunContextLogger.java

@@ -51,10 +51,12 @@ public class RunContextLogger implements Supplier<org.slf4j.Logger> {
     }
 
     public RunContextLogger(QueueInterface<LogEntry> logQueue, LogEntry logEntry, org.slf4j.event.Level loglevel, boolean logToFile) {
-        if (logEntry.getExecutionId() != null) {
-            this.loggerName = "flow." + logEntry.getFlowId() + "." + logEntry.getExecutionId() + (logEntry.getTaskRunId() != null ? "." + logEntry.getTaskRunId() : "");
-        } else {
+        if (logEntry.getTaskId() != null) {
+            this.loggerName = "flow." + logEntry.getFlowId() + "." + logEntry.getTaskId();
+        } else if (logEntry.getTriggerId() != null) {
             this.loggerName = "flow." + logEntry.getFlowId() + "." + logEntry.getTriggerId();
+        } else {
+            this.loggerName = "flow." + logEntry.getFlowId();
         }
 
         this.logQueue = logQueue;
@@ -258,7 +260,8 @@ public class RunContextLogger implements Supplier<org.slf4j.Logger> {
             } else if (object instanceof String string) {
                 return replaceSecret(string);
             } else {
-                return object;
+                // toString will be called anyway at some point so better to all it now
+                return replaceSecret(object.toString());
             }
         }
 

core/src/main/java/io/kestra/core/runners/RunVariables.java

@@ -11,6 +11,7 @@ import io.kestra.core.models.flows.input.SecretInput;
 import io.kestra.core.models.tasks.Task;
 import io.kestra.core.models.triggers.AbstractTrigger;
 import io.kestra.core.utils.ListUtils;
+import io.kestra.plugin.core.trigger.Schedule;
 import lombok.AllArgsConstructor;
 import lombok.With;
 
@@ -26,6 +27,7 @@ import java.util.function.Consumer;
  */
 public final class RunVariables {
     public static final String SECRET_CONSUMER_VARIABLE_NAME = "addSecretConsumer";
+    public static final String FIXTURE_FILES_KEY = "io.kestra.datatype:test_fixtures_files";
 
     /**
      * Creates an immutable map representation of the given {@link Task}.
@@ -179,9 +181,6 @@ public final class RunVariables {
             // Flow
             if (flow != null) {
                 builder.put("flow", RunVariables.of(flow));
-                if (flow.getVariables() != null) {
-                    builder.put("vars", flow.getVariables());
-                }
             }
 
             // Task
@@ -264,13 +263,8 @@ public final class RunVariables {
                         // if some inputs are of type secret, we decode them
                         final Secret secret = new Secret(secretKey, logger);
                         for (Input<?> input : flow.getInputs()) {
-                            if (input instanceof SecretInput && inputs.containsKey(input.getId())) {
-                                try {
-                                    String decoded = secret.decrypt(((String) inputs.get(input.getId())));
-                                    inputs.put(input.getId(), decoded);
-                                } catch (GeneralSecurityException e) {
-                                    throw new RuntimeException(e);
-                                }
+                            if (input instanceof SecretInput) {
+                                decodeInput(secret, input.getId(), inputs);
                             }
                         }
                     }
@@ -299,16 +293,19 @@ public final class RunVariables {
 
                 if (execution.getTrigger() != null && execution.getTrigger().getVariables() != null) {
                     builder.put("trigger", execution.getTrigger().getVariables());
+
+                    // temporal hack to add back the `schedule`variables
+                    // will be removed in 2.0
+                    if (Schedule.class.getName().equals(execution.getTrigger().getType())) {
+                        // add back its variables inside the `schedule` variables
+                        builder.put("schedule", execution.getTrigger().getVariables());
+                    }
                 }
 
                 if (execution.getLabels() != null) {
                     builder.put("labels", Label.toNestedMap(execution.getLabels()));
                 }
 
-                if (execution.getVariables() != null) {
-                    builder.putAll(execution.getVariables());
-                }
-
                 if (flow == null) {
                     Flow flowFromExecution = Flow.builder()
                         .id(execution.getFlowId())
@@ -320,6 +317,20 @@ public final class RunVariables {
                 }
             }
 
+            // variables
+            Optional.ofNullable(execution)
+                .map(Execution::getVariables)
+                .or(() -> Optional.ofNullable(flow).map(Flow::getVariables))
+                .map(HashMap::new)
+                .ifPresent(variables -> {
+                    Object fixtureFiles = variables.remove(FIXTURE_FILES_KEY);
+                    builder.put("vars", ImmutableMap.copyOf(variables));
+
+                    if (fixtureFiles != null) {
+                        builder.put("files", fixtureFiles);
+                    }
+                });
+
             // Kestra configuration
             if (kestraConfiguration != null) {
                 Map<String, String> kestra = new HashMap<>();
@@ -343,6 +354,23 @@ public final class RunVariables {
 
             return builder.build();
         }
+
+        @SuppressWarnings("unchecked")
+        private void decodeInput(Secret secret, String id, Map<String, Object> inputs) {
+            // find the input value that can be nested in case the input has a '.' in it.
+            if (id.indexOf('.') > -1) {
+                String nestedId = id.substring(0, id.indexOf('.'));
+                String restOfId = id.substring(id.indexOf('.') + 1);
+                decodeInput(secret, restOfId, (Map<String, Object>) inputs.get(nestedId));
+            } else if (inputs.containsKey(id)) {
+                try {
+                    String decoded = secret.decrypt(((String) inputs.get(id)));
+                    inputs.put(id, decoded);
+                } catch (GeneralSecurityException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        }
     }
 
     private RunVariables(){}

core/src/main/java/io/kestra/core/runners/Secret.java

@@ -2,7 +2,6 @@ package io.kestra.core.runners;
 
 import io.kestra.core.encryption.EncryptionService;
 import io.kestra.core.models.tasks.common.EncryptedString;
-import jakarta.annotation.Nullable;
 import org.slf4j.Logger;
 
 import java.security.GeneralSecurityException;
@@ -50,8 +49,11 @@ final class Secret {
                     try {
                         String decoded = decrypt((String) map.get("value"));
                         decryptedMap.put(entry.getKey(), decoded);
-                    } catch (GeneralSecurityException e) {
-                        throw new RuntimeException(e);
+                    } catch (GeneralSecurityException | IllegalArgumentException e) {
+                        // NOTE: in rare cases, if for ex a Worker didn't have the encryption but an Executor has it,
+                        // we can have a non-encrypted output that we try to decrypt, this will lead to an IllegalArgumentException.
+                        // As it could break the executor, the best is to do nothing in this case and only log an error.
+                        logger.get().warn("Unable to decrypt the output", e);
                     }
                 }  else {
                     decryptedMap.put(entry.getKey(), decrypt((Map<String, Object>) map));

core/src/main/java/io/kestra/core/runners/Worker.java

@@ -19,6 +19,7 @@ import io.kestra.core.serializers.JacksonMapper;
 import io.kestra.core.server.*;
 import io.kestra.core.services.LabelService;
 import io.kestra.core.services.LogService;
+import io.kestra.core.services.MaintenanceService;
 import io.kestra.core.services.WorkerGroupService;
 import io.kestra.core.trace.TraceUtils;
 import io.kestra.core.trace.Tracer;
@@ -153,6 +154,9 @@ public class Worker implements Service, Runnable, AutoCloseable {
     private TracerFactory tracerFactory;
     private Tracer tracer;
 
+    @Inject
+    private MaintenanceService maintenanceService;
+
     /**
      * Creates a new {@link Worker} instance.
      *
@@ -276,8 +280,12 @@ public class Worker implements Service, Runnable, AutoCloseable {
         ));
 
         this.clusterEventQueue.ifPresent(clusterEventQueueInterface -> this.receiveCancellations.addFirst(clusterEventQueueInterface.receive(this::clusterEventQueue)));
+        if (this.maintenanceService.isInMaintenanceMode()) {
+            enterMaintenance();
+        } else {
+            setState(ServiceState.RUNNING);
+        }
 
-        setState(ServiceState.RUNNING);
         if (workerGroupKey != null) {
             log.info("Worker started with {} thread(s) in group '{}'", numThreads, workerGroupKey);
         }
@@ -295,21 +303,25 @@ public class Worker implements Service, Runnable, AutoCloseable {
         ClusterEvent clusterEvent = either.getLeft();
         log.info("Cluster event received: {}", clusterEvent);
         switch (clusterEvent.eventType()) {
-            case MAINTENANCE_ENTER -> {
-                this.executionKilledQueue.pause();
-                this.workerJobQueue.pause();
-
-                this.setState(ServiceState.MAINTENANCE);
-            }
-            case MAINTENANCE_EXIT -> {
-                this.executionKilledQueue.resume();
-                this.workerJobQueue.resume();
-
-                this.setState(ServiceState.RUNNING);
-            }
+            case MAINTENANCE_ENTER -> enterMaintenance();
+            case MAINTENANCE_EXIT -> exitMaintenance();
         }
     }
 
+    private void enterMaintenance() {
+        this.executionKilledQueue.pause();
+        this.workerJobQueue.pause();
+
+        this.setState(ServiceState.MAINTENANCE);
+    }
+
+    private void exitMaintenance() {
+        this.executionKilledQueue.resume();
+        this.workerJobQueue.resume();
+
+        this.setState(ServiceState.RUNNING);
+    }
+
     private void setState(final ServiceState state) {
         this.state.set(state);
         Map<String, Object> properties = new HashMap<>();
@@ -386,11 +398,16 @@ public class Worker implements Service, Runnable, AutoCloseable {
                     } catch (IllegalVariableEvaluationException e) {
                         RunContextLogger contextLogger = runContextLoggerFactory.create(currentWorkerTask.getTaskRun(), currentWorkerTask.getTask());
                         contextLogger.logger().error("Failed evaluating runIf: {}", e.getMessage(), e);
+                        try {
+                            this.workerTaskResultQueue.emit(new WorkerTaskResult(workerTask.fail()));
+                        } catch (QueueException ex) {
+                            log.error("Unable to emit the worker task result for task {} taskrun {}", currentWorkerTask.getTask().getId(), currentWorkerTask.getTaskRun().getId(), e);
+                        }
                     } catch (QueueException e) {
                         log.error("Unable to emit the worker task result for task {} taskrun {}", currentWorkerTask.getTask().getId(), currentWorkerTask.getTaskRun().getId(), e);
                     }
 
-                    if (workerTaskResult.getTaskRun().getState().isFailed() && !currentWorkerTask.getTask().isAllowFailure()) {
+                    if (workerTaskResult == null || workerTaskResult.getTaskRun().getState().isFailed() && !currentWorkerTask.getTask().isAllowFailure()) {
                         break;
                     }
 
@@ -615,7 +632,7 @@ public class Worker implements Service, Runnable, AutoCloseable {
                 ));
         }
 
-        if (killedExecution.contains(workerTask.getTaskRun().getExecutionId())) {
+        if (! Boolean.TRUE.equals(workerTask.getTaskRun().getForceExecution()) && killedExecution.contains(workerTask.getTaskRun().getExecutionId())) {
             WorkerTaskResult workerTaskResult = new WorkerTaskResult(workerTask.getTaskRun().withState(KILLED));
             try {
                 this.workerTaskResultQueue.emit(workerTaskResult);

core/src/main/java/io/kestra/core/runners/WorkerJobRunningStateStore.java

@@ -0,0 +1,20 @@
+package io.kestra.core.runners;
+
+/**
+ * State store containing all workers' jobs in RUNNING state.
+ *
+ * @see WorkerJob
+ */
+public interface WorkerJobRunningStateStore {
+
+    /**
+     * Deletes a running worker job for the given key.
+     *
+     * <p>
+     *     A key can be a {@link WorkerTask} Task Run ID.
+     * </p>
+     *
+     * @param key the key of the worker job to be deleted.
+     */
+    void deleteByKey(String key);
+}

core/src/main/java/io/kestra/core/runners/pebble/filters/DateAddFilter.java

@@ -24,7 +24,7 @@ public class DateAddFilter extends AbstractDate implements Filter {
             return null;
         }
 
-        final Long amount = (Long) args.get("amount");
+        final Long amount = getAsLong(args.get("amount"), lineNumber, self);
         final String unit = (String) args.get("unit");
         final String timeZone = (String) args.get("timeZone");
         final String existingFormat = (String) args.get("existingFormat");
@@ -36,4 +36,24 @@ public class DateAddFilter extends AbstractDate implements Filter {
 
         return format(plus, args, context);
     }
+
+    public static Long getAsLong(Object value, int lineNumber, PebbleTemplate self) {
+        if (value instanceof Long longValue) {
+            return longValue;
+        } else if (value instanceof Integer integerValue) {
+            return integerValue.longValue();
+        } else if (value instanceof Number numberValue) {
+            return numberValue.longValue();
+        } else if (value instanceof String stringValue) {
+            try {
+                return Long.parseLong(stringValue);
+            } catch (NumberFormatException e) {
+                throw new PebbleException(e, "%s can't be converted to long".formatted(stringValue),
+                    lineNumber, self != null ? self.getName() : "Unknown");
+            }
+        }
+        throw new PebbleException(null, "Incorrect %s format, must be a number".formatted(value),
+            lineNumber, self != null ? self.getName() : "Unknown");
+    }
+
 }

core/src/main/java/io/kestra/core/schedulers/AbstractScheduler.java

@@ -84,12 +84,14 @@ public abstract class AbstractScheduler implements Scheduler, Service {
     private final LogService logService;
     protected SchedulerExecutionStateInterface executionState;
     private final WorkerGroupExecutorInterface workerGroupExecutorInterface;
+    private final MaintenanceService maintenanceService;
 
     // must be volatile as it's updated by the flow listener thread and read by the scheduleExecutor thread
     private volatile Boolean isReady = false;
 
     private final ScheduledExecutorService scheduleExecutor = Executors.newSingleThreadScheduledExecutor();
 
+    @Getter
     protected SchedulerTriggerStateInterface triggerState;
 
     // schedulable and schedulableNextDate must be volatile and their access synchronized as they are updated and read by different threads.
@@ -132,6 +134,8 @@ public abstract class AbstractScheduler implements Scheduler, Service {
         this.serviceStateEventPublisher = applicationContext.getBean(ApplicationEventPublisher.class);
         this.executionEventPublisher = applicationContext.getBean(ApplicationEventPublisher.class);
         this.workerGroupExecutorInterface = applicationContext.getBean(WorkerGroupExecutorInterface.class);
+        this.maintenanceService = applicationContext.getBean(MaintenanceService.class);
+
         setState(ServiceState.CREATED);
     }
 
@@ -259,8 +263,11 @@ public abstract class AbstractScheduler implements Scheduler, Service {
 
         // listen to cluster events
         this.clusterEventQueue.ifPresent(clusterEventQueueInterface -> this.receiveCancellations.addFirst(((QueueInterface<ClusterEvent>) clusterEventQueueInterface).receive(this::clusterEventQueue)));
-
-        setState(ServiceState.RUNNING);
+        if (this.maintenanceService.isInMaintenanceMode()) {
+            enterMaintenance();
+        } else {
+            setState(ServiceState.RUNNING);
+        }
         log.info("Scheduler started");
     }
 
@@ -371,31 +378,35 @@ public abstract class AbstractScheduler implements Scheduler, Service {
         ClusterEvent clusterEvent = either.getLeft();
         log.info("Cluster event received: {}", clusterEvent);
         switch (clusterEvent.eventType()) {
-            case MAINTENANCE_ENTER -> {
-                this.executionQueue.pause();
-                this.triggerQueue.pause();
-                this.workerJobQueue.pause();
-                this.workerTriggerResultQueue.pause();
-                this.executionKilledQueue.pause();
-                this.pauseAdditionalQueues();
-
-                this.isPaused.set(true);
-                this.setState(ServiceState.MAINTENANCE);
-            }
-            case MAINTENANCE_EXIT -> {
-                this.executionQueue.resume();
-                this.triggerQueue.resume();
-                this.workerJobQueue.resume();
-                this.workerTriggerResultQueue.resume();
-                this.executionKilledQueue.resume();
-                this.resumeAdditionalQueues();
-
-                this.isPaused.set(false);
-                this.setState(ServiceState.RUNNING);
-            }
+            case MAINTENANCE_ENTER -> enterMaintenance();
+            case MAINTENANCE_EXIT -> exitMaintenance();
         }
     }
 
+    private void enterMaintenance() {
+        this.executionQueue.pause();
+        this.triggerQueue.pause();
+        this.workerJobQueue.pause();
+        this.workerTriggerResultQueue.pause();
+        this.executionKilledQueue.pause();
+        this.pauseAdditionalQueues();
+
+        this.isPaused.set(true);
+        this.setState(ServiceState.MAINTENANCE);
+    }
+
+    private void exitMaintenance() {
+        this.executionQueue.resume();
+        this.triggerQueue.resume();
+        this.workerJobQueue.resume();
+        this.workerTriggerResultQueue.resume();
+        this.executionKilledQueue.resume();
+        this.resumeAdditionalQueues();
+
+        this.isPaused.set(false);
+        this.setState(ServiceState.RUNNING);
+    }
+
     protected void resumeAdditionalQueues() {
         // by default: do nothing
     }
@@ -967,6 +978,8 @@ public abstract class AbstractScheduler implements Scheduler, Service {
             }
 
             setState(ServiceState.TERMINATING);
+            this.receiveCancellations.forEach(Runnable::run);
+            this.scheduleExecutor.shutdown();
             try {
                 if (onClose != null) {
                     onClose.run();
@@ -974,8 +987,6 @@ public abstract class AbstractScheduler implements Scheduler, Service {
             } catch (Exception e) {
                 log.error("Unexpected error while terminating scheduler.", e);
             }
-            this.receiveCancellations.forEach(Runnable::run);
-            this.scheduleExecutor.shutdown();
             setState(ServiceState.TERMINATED_GRACEFULLY);
 
             if (log.isDebugEnabled()) {

core/src/main/java/io/kestra/core/serializers/FileSerde.java

@@ -201,7 +201,7 @@ public final class FileSerde {
         }
     }
 
-    private static <T> SequenceWriter createSequenceWriter(ObjectMapper objectMapper, Writer writer, TypeReference<T> type) throws IOException {
+    public static <T> SequenceWriter createSequenceWriter(ObjectMapper objectMapper, Writer writer, TypeReference<T> type) throws IOException {
         return objectMapper.writerFor(type).writeValues(writer);
     }
 

core/src/main/java/io/kestra/core/serializers/JacksonMapper.java

@@ -5,6 +5,7 @@ import com.amazon.ion.IonSystem;
 import com.amazon.ion.system.*;
 import com.fasterxml.jackson.annotation.JsonInclude;
 import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.StreamReadConstraints;
 import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.DeserializationFeature;
 import com.fasterxml.jackson.databind.JsonNode;
@@ -36,6 +37,8 @@ import java.util.List;
 import java.util.Map;
 import java.util.TimeZone;
 
+import static com.fasterxml.jackson.core.StreamReadConstraints.DEFAULT_MAX_STRING_LEN;
+
 public final class JacksonMapper {
     public static final TypeReference<Map<String, Object>> MAP_TYPE_REFERENCE = new TypeReference<>() {};
     public static final TypeReference<List<Object>> LIST_TYPE_REFERENCE = new TypeReference<>() {};
@@ -43,6 +46,12 @@ public final class JacksonMapper {
 
     private JacksonMapper() {}
 
+    static {
+        StreamReadConstraints.overrideDefaultStreamReadConstraints(
+            StreamReadConstraints.builder().maxNameLength(DEFAULT_MAX_STRING_LEN).build()
+        );
+    }
+
     private static final ObjectMapper MAPPER = JacksonMapper.configure(
         new ObjectMapper()
     );
@@ -52,7 +61,7 @@ public final class JacksonMapper {
         .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 
     public static ObjectMapper ofJson() {
-        return MAPPER;
+        return JacksonMapper.ofJson(true);
     }
 
     public static ObjectMapper ofJson(boolean strict) {

core/src/main/java/io/kestra/core/server/AbstractServiceLivenessCoordinator.java

@@ -136,6 +136,9 @@ public abstract class AbstractServiceLivenessCoordinator extends AbstractService
         // ...all services that have transitioned to TERMINATED_FORCED.
         uncleanShutdownServices.addAll(instances.stream()
             .filter(nonRunning -> nonRunning.is(Service.ServiceState.TERMINATED_FORCED))
+            // Only select workers that have been terminated for at least the grace period, to ensure that all in-flight
+            // task runs had enough time to be fully handled by the executors.
+            .filter(terminated -> terminated.isTerminationGracePeriodElapsed(now))
             .toList()
         );
         return uncleanShutdownServices;

core/src/main/java/io/kestra/core/server/Service.java

@@ -111,7 +111,7 @@ public interface Service extends AutoCloseable {
      * </pre>
      */
     enum ServiceState {
-        CREATED(1, 2, 3),               // 0
+        CREATED(1, 2, 3, 4, 9),            // 0
         RUNNING(2, 3, 4, 9),            // 1
         ERROR(4),                       // 2
         DISCONNECTED(4, 7),             // 3

core/src/main/java/io/kestra/core/services/ExecutionService.java

@@ -5,11 +5,7 @@ import io.kestra.core.events.CrudEventType;
 import io.kestra.core.exceptions.InternalException;
 import io.kestra.core.models.Label;
 import io.kestra.core.models.conditions.ConditionContext;
-import io.kestra.core.models.executions.Execution;
-import io.kestra.core.models.executions.ExecutionKilled;
-import io.kestra.core.models.executions.ExecutionKilledExecution;
-import io.kestra.core.models.executions.TaskRun;
-import io.kestra.core.models.executions.TaskRunAttempt;
+import io.kestra.core.models.executions.*;
 import io.kestra.core.models.flows.Flow;
 import io.kestra.core.models.flows.FlowWithSource;
 import io.kestra.core.models.flows.State;
@@ -37,8 +33,8 @@ import io.kestra.core.utils.ListUtils;
 import io.kestra.plugin.core.flow.Pause;
 import io.kestra.plugin.core.flow.WorkingDirectory;
 import io.micronaut.context.event.ApplicationEventPublisher;
-import io.micronaut.core.annotation.Nullable;
 import io.micronaut.http.multipart.CompletedPart;
+import jakarta.annotation.Nullable;
 import jakarta.inject.Inject;
 import jakarta.inject.Named;
 import jakarta.inject.Singleton;
@@ -211,7 +207,16 @@ public class ExecutionService {
 
         // We need to remove global error tasks and flowable error tasks if any
         flow
-            .allErrorsWithChilds()
+            .allErrorsWithChildrend()
+            .forEach(task -> newTaskRuns.removeIf(taskRun -> taskRun.getTaskId().equals(task.getId())));
+
+        // We need to remove global finally tasks and flowable error tasks if any
+        flow
+            .allFinallyWithChildren()
+            .forEach(task -> newTaskRuns.removeIf(taskRun -> taskRun.getTaskId().equals(task.getId())));
+
+        // We need to remove afterExecution tasks
+        ListUtils.emptyOnNull(flow.getAfterExecution())
             .forEach(task -> newTaskRuns.removeIf(taskRun -> taskRun.getTaskId().equals(task.getId())));
 
         // Build and launch new execution
@@ -650,30 +655,37 @@ public class ExecutionService {
      *
      * @return the execution in a KILLING state if not already terminated
      */
-    public Execution kill(Execution execution, Flow flow) {
-        if (execution.getState().getCurrent() == State.Type.KILLING || execution.getState().isTerminated()) {
+    public Execution kill(Execution execution, Flow flow, Optional<State.Type> afterKillState) {
+        // We afford the double kill potential (KILLING & afterKillState != null) to ensure we put the afterKillState
+        if ((execution.getState().getCurrent() == State.Type.KILLING && afterKillState.isEmpty()) || execution.getState().isTerminated()) {
             return execution;
         }
 
         Execution newExecution;
+        State.Type killingOrAfterKillState = afterKillState.orElse(State.Type.KILLING);
         if (execution.getState().isPaused()) {
             // Must be resumed and killed, no need to send killing event to the worker as the execution is not executing anything in it.
             // An edge case can exist where the execution is resumed automatically before we resume it with a killing.
             try {
                 newExecution = this.resume(execution, flow, State.Type.KILLING);
+                newExecution = newExecution.withState(afterKillState.orElse(newExecution.getState().getCurrent()));
             } catch (Exception e) {
                 // if we cannot resume, we set it anyway to killing, so we don't throw
                 log.warn("Unable to resume a paused execution before killing it", e);
-                newExecution = execution.withState(State.Type.KILLING);
+                newExecution = execution.withState(killingOrAfterKillState);
             }
         } else {
-            newExecution = execution.withState(State.Type.KILLING);
+            newExecution = execution.withState(killingOrAfterKillState);
         }
 
         eventPublisher.publishEvent(new CrudEvent<>(newExecution, execution, CrudEventType.UPDATE));
         return newExecution;
     }
 
+    public Execution kill(Execution execution, Flow flow) {
+        return this.kill(execution, flow, Optional.empty());
+    }
+
     /**
      * Climb up the hierarchy of parent taskruns and kill them all.
      */

core/src/main/java/io/kestra/core/services/FlowService.java

@@ -132,6 +132,15 @@ public class FlowService {
         }
 
         List<String> warnings = new ArrayList<>(checkValidSubflows(flow, tenantId));
+        List<io.kestra.plugin.core.trigger.Flow> flowTriggers = ListUtils.emptyOnNull(flow.getTriggers()).stream()
+            .filter(io.kestra.plugin.core.trigger.Flow.class::isInstance)
+            .map(io.kestra.plugin.core.trigger.Flow.class::cast)
+            .toList();
+        flowTriggers.forEach(flowTrigger -> {
+            if (ListUtils.emptyOnNull(flowTrigger.getConditions()).isEmpty() && flowTrigger.getPreconditions() == null) {
+                warnings.add("This flow will be triggered for EVERY execution of EVERY flow on your instance. We recommend adding the preconditions property to the Flow trigger '" + flowTrigger.getId() + "'.");
+            }
+        });
 
         return warnings;
     }
@@ -140,7 +149,11 @@ public class FlowService {
         try {
             Map<String, Class<?>> aliases = pluginRegistry.plugins().stream()
                 .flatMap(plugin -> plugin.getAliases().values().stream())
-                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+                .collect(Collectors.toMap(
+                    Map.Entry::getKey,
+                    Map.Entry::getValue,
+                    (existing, duplicate) -> existing
+                ));
             Map<String, Object> stringObjectMap = JacksonMapper.ofYaml().readValue(flowSource, JacksonMapper.MAP_TYPE_REFERENCE);
             return relocations(aliases, stringObjectMap);
         } catch (JsonProcessingException e) {

core/src/main/java/io/kestra/core/services/MaintenanceService.java

@@ -0,0 +1,14 @@
+package io.kestra.core.services;
+
+import jakarta.inject.Singleton;
+
+@Singleton
+public class MaintenanceService {
+    /**
+     * @return true if the cluster is in maintenance mode
+     */
+    public boolean isInMaintenanceMode() {
+        // maintenance mode is an EE feature
+        return false;
+    }
+}

core/src/main/java/io/kestra/core/services/NamespaceService.java

@@ -1,9 +1,11 @@
 package io.kestra.core.services;
 
 import io.kestra.core.repositories.FlowRepositoryInterface;
+import io.kestra.core.utils.NamespaceUtils;
 import jakarta.inject.Inject;
 import jakarta.inject.Singleton;
 
+import java.util.Collection;
 import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
@@ -19,7 +21,7 @@ public class NamespaceService {
     }
 
     /**
-     * Checks whether a given namespace exists.
+     * Checks whether a given namespace exists. A namespace is considered existing if at least one Flow is within the namespace or a parent namespace
      *
      * @param tenant        The tenant ID
      * @param namespace     The namespace - cannot be null.
@@ -29,7 +31,10 @@ public class NamespaceService {
         Objects.requireNonNull(namespace, "namespace cannot be null");
 
         if (flowRepository.isPresent()) {
-            List<String> namespaces = flowRepository.get().findDistinctNamespace(tenant);
+            List<String> namespaces = flowRepository.get().findDistinctNamespace(tenant).stream()
+                .map(NamespaceUtils::asTree)
+                .flatMap(Collection::stream)
+                .toList();
             return namespaces.stream().anyMatch(ns -> ns.equals(namespace) || ns.startsWith(namespace));
         }
         return false;

core/src/main/java/io/kestra/core/topologies/FlowTopologyService.java

@@ -29,7 +29,7 @@ import java.util.stream.Stream;
 @Slf4j
 @Singleton
 public class FlowTopologyService {
-    public static final Label SIMULATED_EXECUTION = new Label(Label.SYSTEM_PREFIX + "simulatedExecution", "true");
+    public static final Label SIMULATED_EXECUTION = new Label(Label.SIMULATED_EXECUTION, "true");
 
     @Inject
     protected ConditionService conditionService;

core/src/main/java/io/kestra/core/utils/Exceptions.java

@@ -22,4 +22,18 @@ public interface Exceptions {
 
         return limitedStackTrace.toString();
     }
+
+    /**
+     * Throws a {@code Throwable} only if it is considered as "fatal" error.
+     *
+     * @param t the exception to evaluate.
+     */
+    static void throwIfFatal(Throwable t) {
+        if (t == null) {
+            return;
+        }
+        if (t instanceof VirtualMachineError error) {
+            throw error;
+        }
+    }
 }

core/src/main/java/io/kestra/core/utils/GraphUtils.java

@@ -73,7 +73,7 @@ public class GraphUtils {
             )))
             .orElse(Collections.emptyMap());
 
-        triggersDeclarations.forEach(trigger -> {
+        triggersDeclarations.stream().filter(trigger -> trigger != null).forEach(trigger -> {
             GraphTrigger triggerNode = new GraphTrigger(trigger, triggersById.get(trigger.getId()));
             triggerCluster.addNode(triggerNode);
             triggerCluster.addEdge(triggerCluster.getRoot(), triggerNode, new Relation());
@@ -361,6 +361,10 @@ public class GraphUtils {
         boolean isFirst = true;
         while (iterator.hasNext()) {
             Task currentTask = iterator.next();
+            if (currentTask == null) {
+                continue;
+            }
+
             for (TaskRun currentTaskRun : findTaskRuns(currentTask, execution, parent)) {
                 AbstractGraph currentGraph;
                 List<String> parentValues = null;

core/src/main/java/io/kestra/core/utils/MapUtils.java

@@ -1,11 +1,15 @@
 package io.kestra.core.utils;
 
 import jakarta.validation.constraints.NotNull;
+import lombok.extern.slf4j.Slf4j;
 
 import java.util.*;
 
 @SuppressWarnings({"rawtypes", "unchecked"})
+@Slf4j
 public class MapUtils {
+    private static final String CONFLICT_AT_KEY_MSG = "Conflict at key: '{}', ignoring it. Map keys are: {}";
+
     public static Map<String, Object> merge(Map<String, Object> a, Map<String, Object> b) {
         if (a == null && b == null) {
             return null;
@@ -136,9 +140,9 @@ public class MapUtils {
     }
 
     /**
-     * Utility method nested a flatten map.
+     * Utility method nested a flattened map.
      *
-     * @param flatMap the flatten map.
+     * @param flatMap the flattened map.
      * @return the nested map.
      *
      * @throws IllegalArgumentException if the given map contains conflicting keys.
@@ -156,13 +160,15 @@ public class MapUtils {
                     currentMap.put(key, new HashMap<>());
                 } else if (!(currentMap.get(key) instanceof Map)) {
                     var invalidKey = String.join(",", Arrays.copyOfRange(keys, 0, i));
-                    throw new IllegalArgumentException("Conflict at key: '" + invalidKey + "'. Map keys are: " + flatMap.keySet());
+                    log.warn(CONFLICT_AT_KEY_MSG, invalidKey, flatMap.keySet());
+                    continue;
                 }
                 currentMap = (Map<String, Object>) currentMap.get(key);
             }
             String lastKey = keys[keys.length - 1];
             if (currentMap.containsKey(lastKey)) {
-                throw new IllegalArgumentException("Conflict at key: '" + lastKey + "', Map keys are: " + flatMap.keySet());
+                log.warn("Conflict at key: '{}', ignoring it. Map keys are: {}", lastKey, flatMap.keySet());
+                continue;
             }
             currentMap.put(lastKey, entry.getValue());
         }

core/src/main/java/io/kestra/core/utils/NamespaceFilesUtils.java

@@ -52,19 +52,15 @@ public class NamespaceFilesUtils {
             .as(FileExistComportment.class).orElse(FileExistComportment.OVERWRITE);
         List<String> namespaces = runContext.render(namespaceFiles.getNamespaces()).asList(String.class);
 
-        Map<String, NamespaceFile> namespaceFileMap = new HashMap<>();
+        List<NamespaceFile> matchedNamespaceFiles = new ArrayList<>();
         for (String namespace : namespaces) {
             List<NamespaceFile> files = runContext.storage()
                 .namespace(namespace)
                 .findAllFilesMatching(include, exclude);
 
-            for (NamespaceFile file : files) {
-                namespaceFileMap.put(file.storagePath().toFile().getName(), file);
-            }
+          matchedNamespaceFiles.addAll(files);
         }
 
-        List<NamespaceFile> matchedNamespaceFiles = new ArrayList<>(namespaceFileMap.values());
-
         Flux.fromIterable(matchedNamespaceFiles)
             .doOnNext(throwConsumer(namespaceFile -> {
                 InputStream content = runContext.storage().getFile(namespaceFile.uri());

core/src/main/java/io/kestra/core/validations/ConditionValidation.java

@@ -1,16 +0,0 @@
-package io.kestra.core.validations;
-
-import io.kestra.core.validations.validator.ConditionValidator;
-import jakarta.validation.Constraint;
-import jakarta.validation.Payload;
-
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-
-@Retention(RetentionPolicy.RUNTIME)
-@Constraint(validatedBy = ConditionValidator.class)
-public @interface ConditionValidation {
-    String message() default "one condition must be set";
-    Class<?>[] groups() default {};
-    Class<? extends Payload>[] payload() default {};
-}

core/src/main/java/io/kestra/core/validations/validator/ConditionValidator.java

@@ -1,22 +0,0 @@
-package io.kestra.core.validations.validator;
-
-import io.kestra.core.validations.ConditionValidation;
-import io.kestra.plugin.core.trigger.Flow;
-import io.micronaut.core.annotation.AnnotationValue;
-import io.micronaut.core.annotation.NonNull;
-import io.micronaut.core.annotation.Nullable;
-import io.micronaut.validation.validator.constraints.ConstraintValidator;
-import io.micronaut.validation.validator.constraints.ConstraintValidatorContext;
-import jakarta.inject.Singleton;
-
-@Singleton
-public class ConditionValidator implements ConstraintValidator<ConditionValidation, Flow> {
-    @Override
-    public boolean isValid(@Nullable Flow value, @NonNull AnnotationValue<ConditionValidation> annotationMetadata, @NonNull ConstraintValidatorContext context) {
-        if (value == null) {
-            return true;
-        }
-
-        return value.getConditions() != null || value.getPreconditions() != null;
-    }
-}

core/src/main/java/io/kestra/plugin/core/execution/Labels.java

@@ -111,8 +111,9 @@ public class Labels extends Task implements ExecutionUpdatableTask {
                     })
                 ).collect(Collectors.toMap(
                     Map.Entry::getKey,
-                    Map.Entry::getValue
-                ));
+                    Map.Entry::getValue,
+                    (first, second) -> second)
+                );
         } else if (labels instanceof Map<?, ?> map) {
             labelsAsMap = map.entrySet()
                 .stream()

core/src/main/java/io/kestra/plugin/core/execution/Resume.java

@@ -1,9 +1,7 @@
 package io.kestra.plugin.core.execution;
 
-import com.ctc.wstx.util.PrefixedName;
 import io.kestra.core.models.annotations.Example;
 import io.kestra.core.models.annotations.Plugin;
-import io.kestra.core.models.annotations.PluginProperty;
 import io.kestra.core.models.executions.Execution;
 import io.kestra.core.models.flows.Flow;
 import io.kestra.core.models.flows.State;
@@ -14,7 +12,7 @@ import io.kestra.core.models.tasks.VoidOutput;
 import io.kestra.core.queues.QueueFactoryInterface;
 import io.kestra.core.queues.QueueInterface;
 import io.kestra.core.repositories.ExecutionRepositoryInterface;
-import io.kestra.core.runners.FlowExecutorInterface;
+import io.kestra.core.runners.FlowMetaStoreInterface;
 import io.kestra.core.runners.DefaultRunContext;
 import io.kestra.core.runners.RunContext;
 import io.kestra.core.services.ExecutionService;
@@ -87,7 +85,7 @@ public class Resume  extends Task implements RunnableTask<VoidOutput> {
         ApplicationContext applicationContext = ((DefaultRunContext)runContext).getApplicationContext();
         ExecutionService executionService = applicationContext.getBean(ExecutionService.class);
         ExecutionRepositoryInterface executionRepository = applicationContext.getBean(ExecutionRepositoryInterface.class);
-        FlowExecutorInterface flowExecutor = applicationContext.getBean(FlowExecutorInterface.class);
+        FlowMetaStoreInterface flowExecutor = applicationContext.getBean(FlowMetaStoreInterface.class);
         QueueInterface<Execution> executionQueue = applicationContext.getBean(QueueInterface.class, Qualifiers.byName(QueueFactoryInterface.EXECUTION_NAMED));
 
         Execution execution = executionRepository.findById(executionInfo.tenantId(), executionInfo.id())

core/src/main/java/io/kestra/plugin/core/execution/SetVariables.java

@@ -0,0 +1,75 @@
+package io.kestra.plugin.core.execution;
+
+import io.kestra.core.models.annotations.Example;
+import io.kestra.core.models.annotations.Plugin;
+import io.kestra.core.models.executions.Execution;
+import io.kestra.core.models.property.Property;
+import io.kestra.core.models.tasks.ExecutionUpdatableTask;
+import io.kestra.core.models.tasks.Task;
+import io.kestra.core.runners.RunContext;
+import io.kestra.core.utils.MapUtils;
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotNull;
+import lombok.*;
+import lombok.experimental.SuperBuilder;
+
+import java.util.List;
+import java.util.Map;
+
+@SuperBuilder
+@ToString
+@EqualsAndHashCode
+@Getter
+@NoArgsConstructor
+@Schema(
+    title = "Allow to set execution variables. These variables will then be available via the `{{ vars.name }}` expression."
+)
+@Plugin(
+    examples = {
+        @Example(
+            full = true,
+            title = "Set variables",
+            code = """
+                id: variables
+                namespace: company.team
+
+                variables:
+                  name: World
+
+                tasks:
+                  - id: set_vars
+                    type: io.kestra.plugin.core.execution.SetVariables
+                    variables:
+                      message: Hello
+                      name: Loïc
+                  - id: hello
+                    type: io.kestra.plugin.core.log.Log
+                    message: "{{ vars.message }} {{ vars.name }}\""""
+        )
+    }
+)
+public class SetVariables extends Task implements ExecutionUpdatableTask {
+    @Schema(title = "The variables")
+    @NotNull
+    private Property<Map<String, Object>> variables;
+
+    @Schema(title = "Whether to overwrite existing variables")
+    @NotNull
+    @Builder.Default
+    private Property<Boolean> overwrite = Property.ofValue(true);
+
+    @Override
+    public Execution update(Execution execution, RunContext runContext) throws Exception {
+        Map<String, Object> renderedVars = runContext.render(this.variables).asMap(String.class, Object.class);
+        boolean renderedOverwrite = runContext.render(overwrite).as(Boolean.class).orElseThrow();
+        if (!renderedOverwrite) {
+            // check that none of the new variables already exist
+            List<String> duplicated = renderedVars.keySet().stream().filter(key -> execution.getVariables().containsKey(key)).toList();
+            if (!duplicated.isEmpty()) {
+                throw new IllegalArgumentException("`overwrite` is set to false and the following variables already exist: " + String.join(",", duplicated));
+            }
+        }
+
+        return execution.withVariables(MapUtils.merge(execution.getVariables(), renderedVars));
+    }
+}

core/src/main/java/io/kestra/plugin/core/execution/UnsetVariables.java

@@ -0,0 +1,89 @@
+package io.kestra.plugin.core.execution;
+
+import io.kestra.core.models.annotations.Example;
+import io.kestra.core.models.annotations.Plugin;
+import io.kestra.core.models.executions.Execution;
+import io.kestra.core.models.property.Property;
+import io.kestra.core.models.tasks.ExecutionUpdatableTask;
+import io.kestra.core.models.tasks.Task;
+import io.kestra.core.runners.RunContext;
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotNull;
+import lombok.*;
+import lombok.experimental.SuperBuilder;
+
+import java.util.List;
+import java.util.Map;
+
+@SuperBuilder
+@ToString
+@EqualsAndHashCode
+@Getter
+@NoArgsConstructor
+@Schema(
+    title = "Allow to unset execution variables."
+)
+@Plugin(
+    examples = {
+        @Example(
+            full = true,
+            title = "Set and later unset variables",
+            code = """
+                id: variables
+                namespace: company.team
+
+                variables:
+                  name: World
+
+                tasks:
+                  - id: set_vars
+                    type: io.kestra.plugin.core.execution.SetVariables
+                    variables:
+                      message: Hello
+                      name: Loïc
+                  - id: hello
+                    type: io.kestra.plugin.core.log.Log
+                    message: "{{ vars.message }} {{ vars.name }}"
+                  - id: unset_variables
+                    type: io.kestra.plugin.core.execution.UnsetVariables
+                    variables:
+                      - message
+                      - name"""
+        )
+    }
+)
+public class UnsetVariables extends Task implements ExecutionUpdatableTask {
+    @Schema(title = "The variables")
+    @NotNull
+    private Property<List<String>> variables;
+
+    @Schema(title = "Whether to ignore missing variables")
+    @NotNull
+    @Builder.Default
+    private Property<Boolean> ignoreMissing = Property.ofValue(false);
+
+
+    @Override
+    public Execution update(Execution execution, RunContext runContext) throws Exception {
+        List<String> renderedVariables = runContext.render(variables).asList(String.class);
+        boolean renderedIgnoreMissing = runContext.render(ignoreMissing).as(Boolean.class).orElseThrow();
+        Map<String, Object> variables = execution.getVariables();
+        for (String key : renderedVariables) {
+            removeVar(variables, key, renderedIgnoreMissing);
+        }
+        return execution.withVariables(variables);
+    }
+
+    private void removeVar(Map<String, Object> vars, String key, boolean ignoreMissing) {
+        if (key.indexOf('.') >= 0) {
+            String prefix = key.substring(0, key.indexOf('.'));
+            String suffix = key.substring(key.indexOf('.') + 1);
+            removeVar((Map<String, Object>) vars.get(prefix), suffix, ignoreMissing);
+        } else {
+            if (ignoreMissing && !vars.containsKey(key)) {
+                return;
+            }
+            vars.remove(key);
+        }
+    }
+}

core/src/main/java/io/kestra/plugin/core/flow/ForEachItem.java

@@ -467,7 +467,7 @@ public class ForEachItem extends Task implements FlowableTask<VoidOutput>, Child
         @Override
         public List<SubflowExecution<?>> createSubflowExecutions(
             RunContext runContext,
-            FlowExecutorInterface flowExecutorInterface,
+            FlowMetaStoreInterface flowExecutorInterface,
             Flow currentFlow,
             Execution currentExecution,
             TaskRun currentTaskRun

core/src/main/java/io/kestra/plugin/core/flow/LoopUntil.java

@@ -12,6 +12,7 @@ import io.kestra.core.models.flows.State;
 import io.kestra.core.models.hierarchies.AbstractGraph;
 import io.kestra.core.models.hierarchies.GraphCluster;
 import io.kestra.core.models.hierarchies.RelationType;
+import io.kestra.core.models.property.Property;
 import io.kestra.core.models.tasks.FlowableTask;
 import io.kestra.core.models.tasks.ResolvedTask;
 import io.kestra.core.models.tasks.Task;
@@ -90,19 +91,17 @@ public class LoopUntil extends Task implements FlowableTask<LoopUntil.Output> {
     private List<Task> tasks;
 
     @NotNull
-    @PluginProperty(dynamic = true)
     @Schema(
         title = "The condition expression that should evaluate to `true` or `false`.",
         description = "Boolean coercion allows 0, -0, null and '' to evaluate to false; all other values will evaluate to true."
     )
-    private String condition;
+    private Property<String> condition;
 
     @Schema(
         title = "If set to `true`, the task run will end in a failed state once the `maxIterations` or `maxDuration` are reached."
     )
     @Builder.Default
-    @PluginProperty
-    private Boolean failOnMaxReached = false;
+    private Property<Boolean> failOnMaxReached = Property.of(false);
 
     @Schema(
         title = "Check the frequency configuration."
@@ -159,16 +158,16 @@ public class LoopUntil extends Task implements FlowableTask<LoopUntil.Output> {
 
     public Instant nextExecutionDate(RunContext runContext, Execution execution, TaskRun parentTaskRun) throws IllegalVariableEvaluationException {
         if (!this.reachedMaximums(runContext, execution, parentTaskRun, false)) {
-            String continueLoop = runContext.render(this.condition);
+            String continueLoop = runContext.render(this.condition).as(String.class).orElse(null);
             if (!TruthUtils.isTruthy(continueLoop)) {
-                return Instant.now().plus(this.checkFrequency.interval);
+                return Instant.now().plus(runContext.render(this.getCheckFrequency().getInterval()).as(Duration.class).orElseThrow());
             }
         }
 
         return null;
     }
 
-    private boolean reachedMaximums(RunContext runContext, Execution execution, TaskRun parentTaskRun, Boolean printLog) {
+    private boolean reachedMaximums(RunContext runContext, Execution execution, TaskRun parentTaskRun, Boolean printLog) throws IllegalVariableEvaluationException {
         Logger logger = runContext.logger();
 
         if (!this.childTaskRunExecuted(execution, parentTaskRun)) {
@@ -178,14 +177,18 @@ public class LoopUntil extends Task implements FlowableTask<LoopUntil.Output> {
         Integer iterationCount = Optional.ofNullable(parentTaskRun.getOutputs())
             .map(outputs -> (Integer) outputs.get("iterationCount"))
             .orElse(0);
-        if (this.checkFrequency.maxIterations != null && iterationCount != null && iterationCount > this.checkFrequency.maxIterations) {
+
+        Optional<Integer> maxIterations = runContext.render(this.getCheckFrequency().getMaxIterations()).as(Integer.class);
+        if (maxIterations.isPresent() && iterationCount != null && iterationCount > maxIterations.get()) {
             if (printLog) {logger.warn("Max iterations reached");}
             return true;
         }
 
         Instant creationDate = parentTaskRun.getState().getHistories().getFirst().getDate();
-        if (this.checkFrequency.maxDuration != null &&
-            creationDate != null && creationDate.plus(this.checkFrequency.maxDuration).isBefore(Instant.now())) {
+        Optional<Duration> maxDuration = runContext.render(this.getCheckFrequency().getMaxDuration()).as(Duration.class);
+        if (maxDuration.isPresent()
+            && creationDate != null
+            && creationDate.plus(maxDuration.get()).isBefore(Instant.now())) {
             if (printLog) {logger.warn("Max duration reached");}
 
             return true;
@@ -201,7 +204,10 @@ public class LoopUntil extends Task implements FlowableTask<LoopUntil.Output> {
             return Optional.empty();
         }
 
-        if (childTaskExecuted && this.reachedMaximums(runContext, execution, parentTaskRun, true) && this.failOnMaxReached) {
+        if (childTaskExecuted
+            && this.reachedMaximums(runContext, execution, parentTaskRun, true)
+            && Boolean.TRUE.equals(runContext.render(this.failOnMaxReached).as(Boolean.class).orElseThrow())
+        ) {
             return Optional.of(State.Type.FAILED);
         }
 
@@ -234,7 +240,7 @@ public class LoopUntil extends Task implements FlowableTask<LoopUntil.Output> {
     @SuppressWarnings("unchecked")
     @Override
     public LoopUntil.Output outputs(RunContext runContext) throws IllegalVariableEvaluationException {
-       Map<String, Object> outputs = (Map<String, Object>) runContext.getVariables().get("outputs");
+        Map<String, Object> outputs = (Map<String, Object>) runContext.getVariables().get("outputs");
         if (outputs != null && outputs.get(this.id) != null) {
             return Output.builder().iterationCount((Integer) ((Map<String, Object>) outputs.get(this.id)).get("iterationCount")).build();
         }
@@ -269,21 +275,18 @@ public class LoopUntil extends Task implements FlowableTask<LoopUntil.Output> {
             title = "Maximum count of iterations."
         )
         @Builder.Default
-        @PluginProperty
-        private Integer maxIterations = 100;
+        private Property<Integer> maxIterations = Property.of(100);
 
         @Schema(
             title = "Maximum duration of the task."
         )
         @Builder.Default
-        @PluginProperty
-        private Duration maxDuration = Duration.ofHours(1);
+        private Property<Duration> maxDuration = Property.of(Duration.ofHours(1));
 
         @Schema(
             title = "Interval between each iteration."
         )
         @Builder.Default
-        @PluginProperty
-        private Duration interval = Duration.ofSeconds(1);
+        private Property<Duration> interval = Property.of(Duration.ofSeconds(1));
     }
 }