From 5891c5c14184abeea96b9fd8d8f3881111413f38 Mon Sep 17 00:00:00 2001
From: Timo Steuerwald <stt1rlz@bosch.com>
Date: Tue, 28 Jul 2026 16:04:47 +0200
Subject: [PATCH 01/23] Mainly cherry picked commits from internal branch

These commits have been squashed together to ease review.
After cherry pick some conflicts have been solved wrong, this is why
there are two additional commits also.

For details please also have a look onto the internal branch in etas-eng
feature/create-process-launch-fit-specification-unverified

The original commit message of this commit:

Add a log message for SIGTERM receival

Move dir tests/integration/lm_shutdown to tests/integration/lm_shutdown_during_rt_switch

Update references accordingly

Add lm_shutdown_during_switch_to_off

A test which verifies that a launch manager shutdown signalled via SIGTERM does not cancel existent switches to off.
Currently does not fail, but should fail. As switch to off gets cancelled and reinitiated by launch manager code.

Let test fail, as switch to off is cancelled by lm

Revert to 1s timeout for lm shutdown & add some comments

Still not 100% stable.

Fix cherry pick odyssey

Former fix for SIGSEGV of old branch
---
 .../process_group_manager.cpp                 |  29 ++-
 .../lm_shutdown_during_rt_switch/BUILD        |  62 ++++++
 .../lm_shutdown_during_rt_switch/common.hpp   |  34 +++
 .../component_a.cpp                           |  61 ++++++
 .../component_c.cpp                           |  46 ++++
 .../control_client_mock.cpp                   |  76 +++++++
 .../lm_shutdown_during_rt_switch.json         | 114 ++++++++++
 .../lm_shutdown_during_rt_switch.py           | 160 ++++++++++++++
 .../lm_shutdown_during_switch_to_off/BUILD    |  55 +++++
 .../common.hpp                                |  30 +++
 .../component_a.cpp                           |  67 ++++++
 .../control_client_mock.cpp                   |  74 +++++++
 .../lm_shutdown_during_switch_to_off.json     |  98 +++++++++
 .../lm_shutdown_during_switch_to_off.py       | 196 ++++++++++++++++++
 14 files changed, 1093 insertions(+), 9 deletions(-)
 create mode 100644 tests/integration/lm_shutdown_during_rt_switch/BUILD
 create mode 100644 tests/integration/lm_shutdown_during_rt_switch/common.hpp
 create mode 100644 tests/integration/lm_shutdown_during_rt_switch/component_a.cpp
 create mode 100644 tests/integration/lm_shutdown_during_rt_switch/component_c.cpp
 create mode 100644 tests/integration/lm_shutdown_during_rt_switch/control_client_mock.cpp
 create mode 100644 tests/integration/lm_shutdown_during_rt_switch/lm_shutdown_during_rt_switch.json
 create mode 100644 tests/integration/lm_shutdown_during_rt_switch/lm_shutdown_during_rt_switch.py
 create mode 100644 tests/integration/lm_shutdown_during_switch_to_off/BUILD
 create mode 100644 tests/integration/lm_shutdown_during_switch_to_off/common.hpp
 create mode 100644 tests/integration/lm_shutdown_during_switch_to_off/component_a.cpp
 create mode 100644 tests/integration/lm_shutdown_during_switch_to_off/control_client_mock.cpp
 create mode 100644 tests/integration/lm_shutdown_during_switch_to_off/lm_shutdown_during_switch_to_off.json
 create mode 100644 tests/integration/lm_shutdown_during_switch_to_off/lm_shutdown_during_switch_to_off.py

diff --git a/score/launch_manager/src/daemon/src/process_group_manager/process_group_manager.cpp b/score/launch_manager/src/daemon/src/process_group_manager/process_group_manager.cpp
index 358fa9e11..1d1cd679a 100644
--- a/score/launch_manager/src/daemon/src/process_group_manager/process_group_manager.cpp
+++ b/score/launch_manager/src/daemon/src/process_group_manager/process_group_manager.cpp
@@ -153,10 +153,17 @@ void ProcessGroupManager::deinitialize()
     process_monitor_.reset();
     alive_monitor_thread_->stop();
     configuration_.deinitialize();
-    process_groups_.clear();
 
+    // Stop and join the worker threads BEFORE destroying the process groups.
+    // Worker threads run ProcessInfoNode::doWork(), which dereferences its Graph
+    // (nodeExecuted(), getState(), ...) via a raw back-pointer. If a transition is
+    // still completing on a worker thread (e.g. an in-progress switch to Off that
+    // is allowed to continue during shutdown), destroying the graphs first would be
+    // a use-after-free.
     thread_pool_.reset();
     worker_jobs_.reset();
+
+    process_groups_.clear();
     process_map_.reset();
 }
 
@@ -237,14 +244,15 @@ bool ProcessGroupManager::initializeProcessGroups()
             const auto* states = configuration_.getListOfProcessGroupStates(pg_name).value_or(nullptr);
             const uint32_t num_run_targets = states ? static_cast<uint32_t>(states->size()) : 0U;
 
-            process_groups_.push_back(std::make_shared<Graph>(
-                num_processes + num_run_targets,
-                &configuration_,
-                worker_jobs_,
-                &process_interface_,
-                process_map_,
-                *supervision_control_notifier_.get(),
-                this));
+            process_groups_.push_back(
+                std::make_shared<Graph>(
+                    num_processes + num_run_targets,
+                    &configuration_,
+                    worker_jobs_,
+                    &process_interface_,
+                    process_map_,
+                    *supervision_control_notifier_.get(),
+                    this));
         }
     }
     else
@@ -321,6 +329,7 @@ bool ProcessGroupManager::run()
     bool overflow_logged = false;
 
     if (result)
+    {
         while (!em_cancelled.load())
         {
             // Wait for something to happen...
@@ -350,6 +359,8 @@ bool ProcessGroupManager::run()
 
             watchdog_->serviceWatchdog();
         }
+        LM_LOG_WARN() << "ProcessGroupManager::run() - received SIGTERM, exiting";
+    }
 
     allProcessGroupsOff();
 
diff --git a/tests/integration/lm_shutdown_during_rt_switch/BUILD b/tests/integration/lm_shutdown_during_rt_switch/BUILD
new file mode 100644
index 000000000..29ded4c31
--- /dev/null
+++ b/tests/integration/lm_shutdown_during_rt_switch/BUILD
@@ -0,0 +1,62 @@
+# *******************************************************************************
+# Copyright (c) 2026 Contributors to the Eclipse Foundation
+#
+# See the NOTICE file(s) distributed with this work for additional
+# information regarding copyright ownership.
+#
+# This program and the accompanying materials are made available under the
+# terms of the Apache License Version 2.0 which is available at
+# https://www.apache.org/licenses/LICENSE-2.0
+#
+# SPDX-License-Identifier: Apache-2.0
+# *******************************************************************************
+load("@rules_cc//cc:cc_binary.bzl", "cc_binary")
+load("@rules_cc//cc:cc_library.bzl", "cc_library")
+load("//tests/utils/bazel:integration.bzl", "integration_test")
+
+cc_library(
+    name = "lm_shutdown_common",
+    hdrs = ["common.hpp"],
+)
+
+cc_binary(
+    name = "control_client_mock",
+    srcs = ["control_client_mock.cpp"],
+    deps = [
+        ":lm_shutdown_common",
+        "//score/launch_manager:control_cc",
+        "//score/launch_manager:lifecycle_cc",
+        "//tests/utils/test_helper",
+        "@googletest//:gtest_main",
+    ],
+)
+
+[
+    cc_binary(
+        name = component,
+        srcs = [component + ".cpp"],
+        deps = [
+            ":lm_shutdown_common",
+            "//score/launch_manager:lifecycle_cc",
+            "//tests/utils/test_helper",
+            "@googletest//:gtest_main",
+        ],
+    )
+    for component in [
+        "component_a",
+        "component_c",
+    ]
+]
+
+integration_test(
+    name = "lm_shutdown_during_rt_switch",
+    timeout = "short",
+    srcs = ["lm_shutdown_during_rt_switch.py"],
+    binaries = [
+        ":component_a",
+        ":component_c",
+        ":control_client_mock",
+        "//score/launch_manager",
+    ],
+    config = ":lm_shutdown_during_rt_switch.json",
+)
diff --git a/tests/integration/lm_shutdown_during_rt_switch/common.hpp b/tests/integration/lm_shutdown_during_rt_switch/common.hpp
new file mode 100644
index 000000000..4e45fe3dd
--- /dev/null
+++ b/tests/integration/lm_shutdown_during_rt_switch/common.hpp
@@ -0,0 +1,34 @@
+/********************************************************************************
+ * Copyright (c) 2026 Contributors to the Eclipse Foundation
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information regarding copyright ownership.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Apache License Version 2.0 which is available at
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ ********************************************************************************/
+
+#ifndef SCORE_TESTS_INTEGRATION_LM_SHUTDOWN_COMMON_HPP
+#define SCORE_TESTS_INTEGRATION_LM_SHUTDOWN_COMMON_HPP
+
+#include <string_view>
+
+/// @brief Written by component_a when it has reported running (run_target_a is
+/// active).
+constexpr std::string_view a_started = "component_a_started";
+
+/// @brief Written by component_a when it starts being terminated (i.e. the
+/// switch away from run_target_a has begun). component_a then stalls, which
+/// keeps the run-target switch in progress and gives the test a deterministic
+/// window in which to send SIGTERM to the launch manager.
+constexpr std::string_view a_terminating = "component_a_terminating";
+
+/// @brief Written by component_c when it starts. component_c belongs only to
+/// run_target_c, so this file must NEVER appear: a SIGTERM to the launch manager
+/// during the switch must cancel the pending activation of run_target_c.
+constexpr std::string_view c_started = "component_c_started";
+
+#endif  // SCORE_TESTS_INTEGRATION_LM_SHUTDOWN_COMMON_HPP
diff --git a/tests/integration/lm_shutdown_during_rt_switch/component_a.cpp b/tests/integration/lm_shutdown_during_rt_switch/component_a.cpp
new file mode 100644
index 000000000..3040c70ba
--- /dev/null
+++ b/tests/integration/lm_shutdown_during_rt_switch/component_a.cpp
@@ -0,0 +1,61 @@
+/********************************************************************************
+ * Copyright (c) 2026 Contributors to the Eclipse Foundation
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information regarding copyright ownership.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Apache License Version 2.0 which is available at
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ ********************************************************************************/
+#include <gtest/gtest.h>
+#include <unistd.h>
+
+#include "common.hpp"
+#include "tests/utils/test_helper/test_helper.hpp"
+#include <score/mw/lifecycle/report_running.h>
+
+namespace
+{
+/// @brief How long component_a stalls while it is being terminated. During a
+/// run-target switch the launch manager runs the STOP phase (terminating
+/// no-longer-needed processes) fully before the START phase (activating newly
+/// needed processes). By stalling here, component_a keeps the switch in the STOP
+/// phase, giving the test a deterministic window to send SIGTERM to the launch
+/// manager before run_target_c could ever be activated.
+///
+/// It must be larger than the time the test needs to observe `a_terminating` and
+/// deliver the SIGTERM, and smaller than component_a's configured
+/// shutdown_timeout so the process still exits gracefully (and writes its XML
+/// result) rather than being SIGKILLed.
+constexpr unsigned int kTerminationDelaySeconds = 2U;
+}  // namespace
+
+TEST(LmShutdownDuringRtSwitch, ComponentA)
+{
+    TEST_STEP("Report running")
+    {
+        EXPECT_TRUE(touch_file(a_started)) << "failed to deploy file";
+        score::mw::lifecycle::report_running();
+    }
+
+    // Wait until the launch manager asks us to terminate (SIGTERM), which happens
+    // when the switch away from run_target_a begins.
+    while (!TestRunner::exitRequested)
+    {
+        pause();
+    }
+
+    TEST_STEP("Stall during termination to keep the run-target switch in progress")
+    {
+        EXPECT_TRUE(touch_file(a_terminating)) << "failed to deploy file";
+        static_cast<void>(sleep(kTerminationDelaySeconds));
+    }
+}
+
+int main()
+{
+    return TestRunner(__FILE__).RunTests();
+}
diff --git a/tests/integration/lm_shutdown_during_rt_switch/component_c.cpp b/tests/integration/lm_shutdown_during_rt_switch/component_c.cpp
new file mode 100644
index 000000000..299ef0385
--- /dev/null
+++ b/tests/integration/lm_shutdown_during_rt_switch/component_c.cpp
@@ -0,0 +1,46 @@
+/********************************************************************************
+ * Copyright (c) 2026 Contributors to the Eclipse Foundation
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information regarding copyright ownership.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Apache License Version 2.0 which is available at
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ ********************************************************************************/
+#include <gtest/gtest.h>
+#include <unistd.h>
+
+#include "common.hpp"
+#include "tests/utils/test_helper/test_helper.hpp"
+#include <score/mw/lifecycle/report_running.h>
+
+// component_c belongs only to run_target_c. Because the switch to run_target_c
+// must be cancelled by the SIGTERM sent to the launch manager, this process must
+// never be launched. Should it ever start, it records `c_started`, which makes
+// both the control client and the Python-side assertions fail.
+TEST(LmShutdownDuringRtSwitch, ComponentC)
+{
+    TEST_STEP("Report running")
+    {
+        // This code should be never executed. In Python code there is also an assertion
+        // that component_c must not be started (i.e. c_started should not exist).
+        // This is a second line of defense in case the Python code is not executed or fails to detect the problem.
+        ADD_FAILURE() << "component_c must never be started";
+
+        EXPECT_TRUE(touch_file(c_started));
+        score::mw::lifecycle::report_running();
+    }
+
+    while (!TestRunner::exitRequested)
+    {
+        pause();
+    }
+}
+
+int main()
+{
+    return TestRunner(__FILE__).RunTests();
+}
diff --git a/tests/integration/lm_shutdown_during_rt_switch/control_client_mock.cpp b/tests/integration/lm_shutdown_during_rt_switch/control_client_mock.cpp
new file mode 100644
index 000000000..e3c2b8207
--- /dev/null
+++ b/tests/integration/lm_shutdown_during_rt_switch/control_client_mock.cpp
@@ -0,0 +1,76 @@
+/********************************************************************************
+ * Copyright (c) 2026 Contributors to the Eclipse Foundation
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information regarding copyright ownership.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Apache License Version 2.0 which is available at
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ ********************************************************************************/
+#include <gtest/gtest.h>
+#include <unistd.h>
+#include <filesystem>
+
+#include "common.hpp"
+#include "tests/utils/test_helper/test_helper.hpp"
+#include <score/mw/lifecycle/control_client.h>
+#include <score/mw/lifecycle/report_running.h>
+
+// The Launch Manager shall exit after performing a shutdown - stopping all the
+// processes it owns in dependency order - when requested (i.e. when it receives
+// a SIGTERM). A shutdown request takes priority over an in-progress run-target
+// switch, which must therefore be cancelled.
+//
+// This control client activates run_target_a and then requests a switch to
+// run_target_c. component_a (only part of run_target_a) stalls while it is being
+// terminated during that switch, so the switch is still in progress when the
+// test sends a SIGTERM to the launch manager from the Python side. The launch
+// manager must then cancel the pending switch (component_c, only part of
+// run_target_c, must never start) and shut everything down.
+TEST(LmShutdownDuringRtSwitch, ControlClient)
+{
+    score::mw::lifecycle::ControlClient client{};
+    ASSERT_TRUE(check_clean({test_end_location, a_started, a_terminating, c_started}));
+
+    TEST_STEP("Report running")
+    {
+        score::mw::lifecycle::report_running();
+    }
+
+    TEST_STEP("Activate run_target_a")
+    {
+        score::cpp::stop_token stop_token;
+        auto result = client.ActivateRunTarget("run_target_a").Get(stop_token);
+        EXPECT_TRUE(result.has_value()) << "Activating run_target_a failed: " << result.error().Message();
+        EXPECT_TRUE(std::filesystem::exists(a_started)) << "component_a was not started";
+    }
+
+    TEST_STEP("Request switch to run_target_c")
+    {
+        // Fire-and-forget: this transition is expected to be cancelled by an
+        // external SIGTERM to the launch manager, so we must not wait for a
+        // result. The launch manager will shut this process down instead of ever
+        // completing the switch.
+        client.ActivateRunTarget("run_target_c");
+    }
+
+    // Block until the launch manager terminates us as part of its own shutdown.
+    while (!TestRunner::exitRequested)
+    {
+        pause();
+    }
+
+    TEST_STEP("Verify run_target_c was never activated")
+    {
+        EXPECT_FALSE(std::filesystem::exists(c_started))
+            << "run_target_c must not be activated: a SIGTERM to the launch manager must cancel the pending switch";
+    }
+}
+
+int main()
+{
+    return TestRunner(__FILE__, TerminationBehavior::kWait, TerminationNotification::kTestEnd).RunTests();
+}
diff --git a/tests/integration/lm_shutdown_during_rt_switch/lm_shutdown_during_rt_switch.json b/tests/integration/lm_shutdown_during_rt_switch/lm_shutdown_during_rt_switch.json
new file mode 100644
index 000000000..d1d538b17
--- /dev/null
+++ b/tests/integration/lm_shutdown_during_rt_switch/lm_shutdown_during_rt_switch.json
@@ -0,0 +1,114 @@
+{
+    "schema_version": 1,
+    "defaults": {
+        "deployment_config": {
+            "bin_dir": "/tmp/tests/lm_shutdown_during_rt_switch",
+            "ready_timeout": 1.0,
+            "shutdown_timeout": 1.0,
+            "ready_recovery_action": {
+                "restart": {
+                    "number_of_attempts": 0
+                }
+            },
+            "recovery_action": {
+                "switch_run_target": {
+                    "run_target": "fallback_run_target"
+                }
+            },
+            "environmental_variables": {
+                "LD_LIBRARY_PATH": "/opt/lib"
+            },
+            "sandbox": {
+                "uid": 0,
+                "gid": 0,
+                "scheduling_policy": "SCHED_OTHER",
+                "scheduling_priority": 0
+            }
+        },
+        "component_properties": {
+            "application_profile": {
+                "application_type": "Reporting",
+                "is_self_terminating": false,
+                "alive_supervision": {
+                    "reporting_cycle": 0.1,
+                    "min_indications": 1,
+                    "max_indications": 3,
+                    "failed_cycles_tolerance": 1
+                }
+            },
+            "ready_condition": {
+                "process_state": "Running"
+            }
+        }
+    },
+    "components": {
+        "component_initial": {
+            "component_properties": {
+                "binary_name": "control_client_mock",
+                "application_profile": {
+                    "application_type": "State_Manager",
+                    "alive_supervision": {
+                        "min_indications": 0
+                    }
+                }
+            },
+            "deployment_config": {
+                "ready_timeout": 1.0,
+                "shutdown_timeout": 1.0,
+                "environmental_variables": {
+                    "PROCESSIDENTIFIER": "control_client_mock"
+                }
+            }
+        },
+        "component_a": {
+            "component_properties": {
+                "binary_name": "component_a"
+            },
+            "deployment_config": {
+                "shutdown_timeout": 5.0,
+                "environmental_variables": {
+                    "PROCESSIDENTIFIER": "component_a"
+                }
+            }
+        },
+        "component_c": {
+            "component_properties": {
+                "binary_name": "component_c"
+            },
+            "deployment_config": {
+                "environmental_variables": {
+                    "PROCESSIDENTIFIER": "component_c"
+                }
+            }
+        }
+    },
+    "run_targets": {
+        "Startup": {
+            "depends_on": [
+                "component_initial"
+            ]
+        },
+        "run_target_a": {
+            "depends_on": [
+                "component_initial",
+                "component_a"
+            ]
+        },
+        "run_target_c": {
+            "depends_on": [
+                "component_initial",
+                "component_c"
+            ]
+        },
+        "Off": {
+            "depends_on": []
+        }
+    },
+    "initial_run_target": "Startup",
+    "alive_supervision": {
+        "evaluation_cycle": 0.05
+    },
+    "fallback_run_target": {
+        "depends_on": []
+    }
+}
diff --git a/tests/integration/lm_shutdown_during_rt_switch/lm_shutdown_during_rt_switch.py b/tests/integration/lm_shutdown_during_rt_switch/lm_shutdown_during_rt_switch.py
new file mode 100644
index 000000000..8a0824e15
--- /dev/null
+++ b/tests/integration/lm_shutdown_during_rt_switch/lm_shutdown_during_rt_switch.py
@@ -0,0 +1,160 @@
+# *******************************************************************************
+# Copyright (c) 2026 Contributors to the Eclipse Foundation
+#
+# See the NOTICE file(s) distributed with this work for additional
+# information regarding copyright ownership.
+#
+# This program and the accompanying materials are made available under the
+# terms of the Apache License Version 2.0 which is available at
+# https://www.apache.org/licenses/LICENSE-2.0
+#
+# SPDX-License-Identifier: Apache-2.0
+# *******************************************************************************
+import logging
+import time
+
+from tests.utils.testing_utils.setup_test import setup_test
+from tests.utils.testing_utils.test_results import assert_test_results
+from attribute_plugin import add_test_properties
+
+logger = logging.getLogger(__name__)
+
+
+def _wait_for_file(target, file_path, proc, timeout_s):
+    """Block until `file_path` exists on the target, or raise on timeout / early
+    exit of the launch manager process."""
+    deadline = time.monotonic() + timeout_s
+    while time.monotonic() < deadline:
+        if not proc.is_running():
+            raise RuntimeError(
+                f"Launch manager exited (code {proc.get_exit_code()}) before "
+                f"'{file_path}' appeared. Output:\n{proc.get_output()}"
+            )
+        exit_code, _ = target.execute(f"test -f {file_path}")
+        if exit_code == 0:
+            return
+        time.sleep(0.05)
+    raise TimeoutError(f"'{file_path}' did not appear within {timeout_s}s")
+
+
+def _pids_by_comm(target, name):
+    """Return the PIDs whose process name matches `name`.
+
+    The test sandbox provides neither ``pgrep`` nor ``ps``, so processes are
+    located by scanning ``/proc/<pid>/comm`` using only shell builtins and
+    ``cat``. Linux truncates the process name (``comm``) to 15 characters, so
+    the target name is truncated the same way before comparing.
+    """
+    truncated = name[:15]
+    scan = (
+        "for p in /proc/[0-9]*/comm; do "
+        'c=$(cat "$p" 2>/dev/null) || continue; '
+        f'if [ "$c" = "{truncated}" ]; then '
+        "q=${p#/proc/}; echo ${q%/comm}; fi; "
+        "done"
+    )
+    exit_code, stdout = target.execute(scan)
+    if exit_code != 0:
+        return []
+    return [int(pid) for pid in stdout.decode().split()]
+
+
+def _launch_manager_pid(target):
+    """Return the PID of the running launch_manager process, or None."""
+    pids = _pids_by_comm(target, "launch_manager")
+    return pids[0] if pids else None
+
+
+@add_test_properties(
+    fully_verifies=[],
+    partially_verifies=[
+        "comp_req__lifecycle__launcher_exit_shutdown",
+    ],
+    test_type="requirements-based",
+    derivation_technique="requirements-analysis",
+)
+def test_lm_shutdown(
+    target, setup_test, assert_test_results, remote_test_dir, test_output_dir
+):
+    """
+    Objective: Verifies that the Launch Manager exits after performing a shutdown
+    (stopping all processes it owns) when requested via SIGTERM, and that this
+    shutdown takes priority over an in-progress run-target switch (the switch is
+    cancelled).
+
+    The control client activates run_target_a and then requests a switch to
+    run_target_c. component_a (only part of run_target_a) stalls while it is being
+    terminated during the switch, keeping the switch in progress. At that point
+    the test sends a SIGTERM to the launch manager process (only that process, not
+    the whole group, so the launch manager performs its own orderly shutdown).
+
+    Expected Behaviour: The launch manager cancels the pending switch - so
+    component_c (only part of run_target_c) is never started - stops all the
+    processes it owns, and exits cleanly.
+    """
+
+    new_config_path = str(remote_test_dir / "etc/lm_shutdown_during_rt_switch.bin")
+
+    a_terminating = remote_test_dir / "component_a_terminating"
+    c_started = remote_test_dir / "component_c_started"
+
+    proc = target.execute_async(
+        str(remote_test_dir / "launch_manager"),
+        args=["-c", new_config_path],
+        cwd=str(remote_test_dir),
+    )
+
+    try:
+        # Wait until the switch to run_target_c is underway: component_a is being
+        # terminated (and is now stalling), so run_target_c has not been activated
+        # yet. This state is signalled via file a_terminating.
+        # This is the window in which the shutdown request must win.
+        _wait_for_file(target, a_terminating, proc, timeout_s=10.0)
+
+        # run_target_c must not have started yet at this point.
+        exit_code, _ = target.execute(f"test -f {c_started}")
+        # The assertion below could only fail if either the sleep in component_a's termination code is too short
+        # or component_a has been killed by launch manager, because it takes too long to react on SIGTERM.
+        assert exit_code != 0, (
+            "run_target_c was activated before shutdown was requested - this should not happen"
+        )
+
+        # Request shutdown: send SIGTERM to the launch manager process only, so
+        # that the launch manager itself stops the processes it owns (rather than
+        # the OS terminating the whole process group directly).
+        lm_pid = _launch_manager_pid(target)
+        assert lm_pid is not None, "Could not find the running launch_manager process"
+        logger.info(f"Sending SIGTERM to launch_manager (pid {lm_pid})")
+        exit_code, _ = target.execute(f"kill -15 {lm_pid}")
+        assert exit_code == 0, "Failed to send SIGTERM to the launch manager"
+
+        # The launch manager must exit after completing its shutdown.
+        deadline = time.monotonic() + 10.0
+        while proc.is_running() and time.monotonic() < deadline:
+            time.sleep(0.1)
+        assert not proc.is_running(), (
+            f"Launch manager did not exit after SIGTERM. Output:\n{proc.get_output()}"
+        )
+        assert proc.get_exit_code() == 0, (
+            f"Launch manager did not exit cleanly (code {proc.get_exit_code()}). "
+            f"Output:\n{proc.get_output()}"
+        )
+
+        # The pending switch must have been cancelled: run_target_c never activated.
+        exit_code, _ = target.execute(f"test -f {c_started}")
+        assert exit_code != 0, (
+            "run_target_c was activated: the SIGTERM shutdown request must cancel the pending switch"
+        )
+
+        # The launch manager must have stopped all the processes it owns.
+        for binary in ("component_a", "component_c", "control_client_mock"):
+            running = _pids_by_comm(target, binary)
+            assert not running, (
+                f"'{binary}' is still running (pids {running}) after launch manager shutdown"
+            )
+    finally:
+        if proc.is_running():
+            proc.stop()
+
+    # component_c never runs, so it produces no XML result.
+    assert_test_results({"control_client_mock.xml", "component_a.xml"})
diff --git a/tests/integration/lm_shutdown_during_switch_to_off/BUILD b/tests/integration/lm_shutdown_during_switch_to_off/BUILD
new file mode 100644
index 000000000..3dd1da6f1
--- /dev/null
+++ b/tests/integration/lm_shutdown_during_switch_to_off/BUILD
@@ -0,0 +1,55 @@
+# *******************************************************************************
+# Copyright (c) 2026 Contributors to the Eclipse Foundation
+#
+# See the NOTICE file(s) distributed with this work for additional
+# information regarding copyright ownership.
+#
+# This program and the accompanying materials are made available under the
+# terms of the Apache License Version 2.0 which is available at
+# https://www.apache.org/licenses/LICENSE-2.0
+#
+# SPDX-License-Identifier: Apache-2.0
+# *******************************************************************************
+load("@rules_cc//cc:cc_binary.bzl", "cc_binary")
+load("@rules_cc//cc:cc_library.bzl", "cc_library")
+load("//tests/utils/bazel:integration.bzl", "integration_test")
+
+cc_library(
+    name = "lm_shutdown_common",
+    hdrs = ["common.hpp"],
+)
+
+cc_binary(
+    name = "control_client_mock",
+    srcs = ["control_client_mock.cpp"],
+    deps = [
+        ":lm_shutdown_common",
+        "//score/launch_manager:control_cc",
+        "//score/launch_manager:lifecycle_cc",
+        "//tests/utils/test_helper",
+        "@googletest//:gtest_main",
+    ],
+)
+
+cc_binary(
+    name = "component_a",
+    srcs = ["component_a.cpp"],
+    deps = [
+        ":lm_shutdown_common",
+        "//score/launch_manager:lifecycle_cc",
+        "//tests/utils/test_helper",
+        "@googletest//:gtest_main",
+    ],
+)
+
+integration_test(
+    name = "lm_shutdown_during_switch_to_off",
+    timeout = "short",
+    srcs = ["lm_shutdown_during_switch_to_off.py"],
+    binaries = [
+        ":component_a",
+        ":control_client_mock",
+        "//score/launch_manager",
+    ],
+    config = ":lm_shutdown_during_switch_to_off.json",
+)
diff --git a/tests/integration/lm_shutdown_during_switch_to_off/common.hpp b/tests/integration/lm_shutdown_during_switch_to_off/common.hpp
new file mode 100644
index 000000000..f3b5eb946
--- /dev/null
+++ b/tests/integration/lm_shutdown_during_switch_to_off/common.hpp
@@ -0,0 +1,30 @@
+/********************************************************************************
+ * Copyright (c) 2026 Contributors to the Eclipse Foundation
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information regarding copyright ownership.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Apache License Version 2.0 which is available at
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ ********************************************************************************/
+
+#ifndef SCORE_TESTS_INTEGRATION_LM_SHUTDOWN_DURING_SWITCH_TO_OFF_COMMON_HPP
+#define SCORE_TESTS_INTEGRATION_LM_SHUTDOWN_DURING_SWITCH_TO_OFF_COMMON_HPP
+
+#include <string_view>
+
+/// @brief Written by component_a when it has reported running (run_target_a is
+/// active).
+constexpr std::string_view a_started = "component_a_started";
+
+/// @brief Written by component_a when it starts being terminated (i.e. the
+/// switch away from run_target_a - here, the switch to the "Off" run target -
+/// has begun). component_a then stalls, which keeps the run-target switch in
+/// progress and gives the test a deterministic window in which to send SIGTERM
+/// to the launch manager.
+constexpr std::string_view a_terminating = "component_a_terminating";
+
+#endif  // SCORE_TESTS_INTEGRATION_LM_SHUTDOWN_DURING_SWITCH_TO_OFF_COMMON_HPP
diff --git a/tests/integration/lm_shutdown_during_switch_to_off/component_a.cpp b/tests/integration/lm_shutdown_during_switch_to_off/component_a.cpp
new file mode 100644
index 000000000..26b9633eb
--- /dev/null
+++ b/tests/integration/lm_shutdown_during_switch_to_off/component_a.cpp
@@ -0,0 +1,67 @@
+/********************************************************************************
+ * Copyright (c) 2026 Contributors to the Eclipse Foundation
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information regarding copyright ownership.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Apache License Version 2.0 which is available at
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ ********************************************************************************/
+#include <gtest/gtest.h>
+#include <unistd.h>
+
+#include "common.hpp"
+#include "tests/utils/test_helper/test_helper.hpp"
+#include <score/mw/lifecycle/report_running.h>
+
+namespace
+{
+/// @brief How long component_a stalls while it is being terminated. During a
+/// run-target switch the launch manager runs the STOP phase (terminating
+/// no-longer-needed processes) fully before the START phase (activating newly
+/// needed processes). By stalling here, component_a keeps the switch (to the
+/// "Off" run target) in the STOP phase, giving the test a deterministic window
+/// to send SIGTERM to the launch manager while the switch to Off is still in
+/// progress.
+///
+/// It must be comfortably larger than the time the test needs to observe
+/// `a_terminating` and deliver the SIGTERM to the launch manager AND larger than
+/// the launch manager's fixed shutdown grace period (see the NOTE in
+/// ProcessGroupManager::allProcessGroupsOff): the shutdown does NOT respect the
+/// per-process shutdown_timeout, so this stall outlives that grace period and
+/// component_a is force-terminated (SIGKILLed) - it does not write an XML result.
+/// It must also be smaller than component_a's configured shutdown_timeout so the
+/// STOP job does not SIGKILL it on its own before the launch manager SIGTERM is
+/// handled (which would end the switch to Off early and defeat the test).
+constexpr unsigned int kTerminationDelaySeconds = 2U;
+}  // namespace
+
+TEST(LmShutdownDuringSwitchToOff, ComponentA)
+{
+    TEST_STEP("Report running")
+    {
+        EXPECT_TRUE(touch_file(a_started)) << "failed to deploy file";
+        score::mw::lifecycle::report_running();
+    }
+
+    // Wait until the launch manager asks us to terminate (SIGTERM), which happens
+    // when the switch away from run_target_a (to the "Off" run target) begins.
+    while (!TestRunner::exitRequested)
+    {
+        pause();
+    }
+
+    TEST_STEP("Stall during termination to keep the run-target switch in progress")
+    {
+        EXPECT_TRUE(touch_file(a_terminating)) << "failed to deploy file";
+        static_cast<void>(sleep(kTerminationDelaySeconds));
+    }
+}
+
+int main()
+{
+    return TestRunner(__FILE__).RunTests();
+}
diff --git a/tests/integration/lm_shutdown_during_switch_to_off/control_client_mock.cpp b/tests/integration/lm_shutdown_during_switch_to_off/control_client_mock.cpp
new file mode 100644
index 000000000..8648d6a59
--- /dev/null
+++ b/tests/integration/lm_shutdown_during_switch_to_off/control_client_mock.cpp
@@ -0,0 +1,74 @@
+/********************************************************************************
+ * Copyright (c) 2026 Contributors to the Eclipse Foundation
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information regarding copyright ownership.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Apache License Version 2.0 which is available at
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ ********************************************************************************/
+#include <gtest/gtest.h>
+#include <unistd.h>
+#include <filesystem>
+
+#include "common.hpp"
+#include "tests/utils/test_helper/test_helper.hpp"
+#include <score/mw/lifecycle/control_client.h>
+#include <score/mw/lifecycle/report_running.h>
+
+// The Launch Manager shall exit after performing a shutdown - stopping all the
+// processes it owns in dependency order - when requested (i.e. when it receives
+// a SIGTERM).
+//
+// This variant differs from lm_shutdown_during_rt_switch: instead of switching
+// to another (non-Off) run target, the control client explicitly switches to
+// the "Off" run target. component_a (part of run_target_a) stalls while it is
+// being terminated during that switch, so the switch to Off is still in progress
+// when the test sends a SIGTERM to the launch manager from the Python side.
+//
+// Because the process group is ALREADY heading to Off, the SIGTERM-triggered
+// shutdown must simply let that in-progress switch to Off continue to completion
+// - it must NOT cancel the explicit switch to Off and redo it. Either way the
+// launch manager must end up stopping everything it owns and exit cleanly.
+TEST(LmShutdownDuringSwitchToOff, ControlClient)
+{
+    score::mw::lifecycle::ControlClient client{};
+    ASSERT_TRUE(check_clean({test_end_location, a_started, a_terminating}));
+
+    TEST_STEP("Report running")
+    {
+        score::mw::lifecycle::report_running();
+    }
+
+    TEST_STEP("Activate run_target_a")
+    {
+        score::cpp::stop_token stop_token;
+        auto result = client.ActivateRunTarget("run_target_a").Get(stop_token);
+        EXPECT_TRUE(result.has_value()) << "Activating run_target_a failed: " << result.error().Message();
+        EXPECT_TRUE(std::filesystem::exists(a_started)) << "component_a was not started";
+    }
+
+    TEST_STEP("Request switch to Off")
+    {
+        // Fire-and-forget: switching to the "Off" run target terminates this
+        // control client too (it is not part of "Off"), so we must not wait for a
+        // result. The launch manager will shut this process down as part of the
+        // switch to Off.
+        client.ActivateRunTarget("Off");
+    }
+
+    // Block until the launch manager terminates us as part of the switch to Off /
+    // its own shutdown.
+    while (!TestRunner::exitRequested)
+    {
+        pause();
+    }
+}
+
+int main()
+{
+    return TestRunner(__FILE__, TerminationBehavior::kWait, TerminationNotification::kTestEnd).RunTests();
+}
diff --git a/tests/integration/lm_shutdown_during_switch_to_off/lm_shutdown_during_switch_to_off.json b/tests/integration/lm_shutdown_during_switch_to_off/lm_shutdown_during_switch_to_off.json
new file mode 100644
index 000000000..b1b9beafa
--- /dev/null
+++ b/tests/integration/lm_shutdown_during_switch_to_off/lm_shutdown_during_switch_to_off.json
@@ -0,0 +1,98 @@
+{
+    "schema_version": 1,
+    "defaults": {
+        "deployment_config": {
+            "bin_dir": "/tmp/tests/lm_shutdown_during_switch_to_off",
+            "ready_timeout": 1.0,
+            "shutdown_timeout": 1.0,
+            "ready_recovery_action": {
+                "restart": {
+                    "number_of_attempts": 0
+                }
+            },
+            "recovery_action": {
+                "switch_run_target": {
+                    "run_target": "fallback_run_target"
+                }
+            },
+            "environmental_variables": {
+                "LD_LIBRARY_PATH": "/opt/lib"
+            },
+            "sandbox": {
+                "uid": 0,
+                "gid": 0,
+                "scheduling_policy": "SCHED_OTHER",
+                "scheduling_priority": 0
+            }
+        },
+        "component_properties": {
+            "application_profile": {
+                "application_type": "Reporting",
+                "is_self_terminating": false,
+                "alive_supervision": {
+                    "reporting_cycle": 0.1,
+                    "min_indications": 1,
+                    "max_indications": 3,
+                    "failed_cycles_tolerance": 1
+                }
+            },
+            "ready_condition": {
+                "process_state": "Running"
+            }
+        }
+    },
+    "components": {
+        "component_initial": {
+            "component_properties": {
+                "binary_name": "control_client_mock",
+                "application_profile": {
+                    "application_type": "State_Manager",
+                    "alive_supervision": {
+                        "min_indications": 0
+                    }
+                }
+            },
+            "deployment_config": {
+                "ready_timeout": 1.0,
+                "shutdown_timeout": 1.0,
+                "environmental_variables": {
+                    "PROCESSIDENTIFIER": "control_client_mock"
+                }
+            }
+        },
+        "component_a": {
+            "component_properties": {
+                "binary_name": "component_a"
+            },
+            "deployment_config": {
+                "shutdown_timeout": 5.0,
+                "environmental_variables": {
+                    "PROCESSIDENTIFIER": "component_a"
+                }
+            }
+        }
+    },
+    "run_targets": {
+        "Startup": {
+            "depends_on": [
+                "component_initial"
+            ]
+        },
+        "run_target_a": {
+            "depends_on": [
+                "component_initial",
+                "component_a"
+            ]
+        },
+        "Off": {
+            "depends_on": []
+        }
+    },
+    "initial_run_target": "Startup",
+    "alive_supervision": {
+        "evaluation_cycle": 0.05
+    },
+    "fallback_run_target": {
+        "depends_on": []
+    }
+}
diff --git a/tests/integration/lm_shutdown_during_switch_to_off/lm_shutdown_during_switch_to_off.py b/tests/integration/lm_shutdown_during_switch_to_off/lm_shutdown_during_switch_to_off.py
new file mode 100644
index 000000000..bc7c7e14d
--- /dev/null
+++ b/tests/integration/lm_shutdown_during_switch_to_off/lm_shutdown_during_switch_to_off.py
@@ -0,0 +1,196 @@
+# *******************************************************************************
+# Copyright (c) 2026 Contributors to the Eclipse Foundation
+#
+# See the NOTICE file(s) distributed with this work for additional
+# information regarding copyright ownership.
+#
+# This program and the accompanying materials are made available under the
+# terms of the Apache License Version 2.0 which is available at
+# https://www.apache.org/licenses/LICENSE-2.0
+#
+# SPDX-License-Identifier: Apache-2.0
+# *******************************************************************************
+import logging
+import time
+
+from tests.utils.testing_utils.setup_test import setup_test
+from tests.utils.testing_utils.test_results import assert_test_results
+from attribute_plugin import add_test_properties
+
+logger = logging.getLogger(__name__)
+
+
+def _wait_for_file(target, file_path, proc, timeout_s):
+    """Block until `file_path` exists on the target, or raise on timeout / early
+    exit of the launch manager process."""
+    deadline = time.monotonic() + timeout_s
+    while time.monotonic() < deadline:
+        if not proc.is_running():
+            raise RuntimeError(
+                f"Launch manager exited (code {proc.get_exit_code()}) before "
+                f"'{file_path}' appeared. Output:\n{proc.get_output()}"
+            )
+        exit_code, _ = target.execute(f"test -f {file_path}")
+        if exit_code == 0:
+            return
+        time.sleep(0.05)
+    raise TimeoutError(f"'{file_path}' did not appear within {timeout_s}s")
+
+
+def _pids_by_comm(target, name):
+    """Return the PIDs whose process name matches `name`.
+
+    The test sandbox provides neither ``pgrep`` nor ``ps``, so processes are
+    located by scanning ``/proc/<pid>/comm`` using only shell builtins and
+    ``cat``. Linux truncates the process name (``comm``) to 15 characters, so
+    the target name is truncated the same way before comparing.
+    """
+    truncated = name[:15]
+    scan = (
+        "for p in /proc/[0-9]*/comm; do "
+        'c=$(cat "$p" 2>/dev/null) || continue; '
+        f'if [ "$c" = "{truncated}" ]; then '
+        "q=${p#/proc/}; echo ${q%/comm}; fi; "
+        "done"
+    )
+    exit_code, stdout = target.execute(scan)
+    if exit_code != 0:
+        return []
+    return [int(pid) for pid in stdout.decode().split()]
+
+
+def _launch_manager_pid(target):
+    """Return the PID of the running launch_manager process, or None."""
+    pids = _pids_by_comm(target, "launch_manager")
+    return pids[0] if pids else None
+
+
+@add_test_properties(
+    fully_verifies=[],
+    partially_verifies=[
+        "comp_req__lifecycle__launcher_exit_shutdown",
+    ],
+    test_type="requirements-based",
+    derivation_technique="requirements-analysis",
+)
+def test_lm_shutdown(
+    target, setup_test, assert_test_results, remote_test_dir, test_output_dir
+):
+    """
+    Objective: Verifies that the Launch Manager exits after performing a shutdown
+    (stopping all processes it owns) when requested via SIGTERM, and that a
+    SIGTERM that arrives while an explicit switch to the "Off" run target is
+    already in progress lets that switch to Off continue to completion (it must
+    NOT be cancelled and redone).
+
+    The control client activates run_target_a and then explicitly requests a
+    switch to the "Off" run target. component_a (part of run_target_a) stalls
+    while it is being terminated during that switch, keeping the switch to Off in
+    progress. At that point the test sends a SIGTERM to the launch manager process
+    (only that process, not the whole group, so the launch manager performs its
+    own orderly shutdown).
+
+    Expected Behaviour: The launch manager lets the in-progress switch to Off
+    continue - it must NOT cancel the explicit switch to Off and redo it - all the
+    processes it owns are stopped, and it exits cleanly.
+
+    NOTE: the launch manager does NOT respect the per-process shutdown_timeout
+    during its own shutdown (see the NOTE in ProcessGroupManager::
+    allProcessGroupsOff). It applies a single fixed grace period to the whole
+    in-progress transition, after which any process still terminating is
+    force-terminated (SIGKILLed). component_a deliberately stalls past that grace
+    period, so it is SIGKILLed and does NOT produce an XML result - this test
+    therefore does not assert on component_a's XML.
+
+    Note: this test currently FAILS. It documents a launch manager defect: on
+    SIGTERM, allProcessGroupsOff() unconditionally cancels every process group -
+    including one that is already transitioning to Off - and then restarts the
+    transition to Off, instead of letting the in-progress switch to Off continue.
+    The test passes once that defect is fixed.
+    """
+
+    new_config_path = str(remote_test_dir / "etc/lm_shutdown_during_switch_to_off.bin")
+
+    a_terminating = remote_test_dir / "component_a_terminating"
+
+    proc = target.execute_async(
+        str(remote_test_dir / "launch_manager"),
+        args=["-c", new_config_path],
+        cwd=str(remote_test_dir),
+    )
+
+    try:
+        # Wait until the switch to Off is underway: component_a is being terminated
+        # (and is now stalling). This is signalled via file a_terminating and is
+        # the window in which the shutdown request arrives.
+        _wait_for_file(target, a_terminating, proc, timeout_s=10.0)
+
+        # Request shutdown: send SIGTERM to the launch manager process only, so
+        # that the launch manager itself stops the processes it owns (rather than
+        # the OS terminating the whole process group directly).
+        lm_pid = _launch_manager_pid(target)
+        assert lm_pid is not None, "Could not find the running launch_manager process"
+        logger.info(f"Sending SIGTERM to launch_manager (pid {lm_pid})")
+        exit_code, _ = target.execute(f"kill -15 {lm_pid}")
+        assert exit_code == 0, "Failed to send SIGTERM to the launch manager"
+
+        # The launch manager must exit after completing its shutdown.
+        deadline = time.monotonic() + 10.0
+        while proc.is_running() and time.monotonic() < deadline:
+            time.sleep(0.1)
+        assert not proc.is_running(), (
+            f"Launch manager did not exit after SIGTERM. Output:\n{proc.get_output()}"
+        )
+        assert proc.get_exit_code() == 0, (
+            f"Launch manager did not exit cleanly (code {proc.get_exit_code()}). "
+            f"Output:\n{proc.get_output()}"
+        )
+
+        # The launch manager must have stopped all the processes it owns.
+        for binary in ("component_a", "control_client_mock"):
+            running = _pids_by_comm(target, binary)
+            assert not running, (
+                f"'{binary}' is still running (pids {running}) after launch manager shutdown"
+            )
+
+        # Core assertion: the explicit switch to Off must be CONTINUED, not
+        # cancelled and redone.
+        #
+        # The switch to Off was already in progress (MainPG in transition to Off)
+        # when the SIGTERM arrived, so the SIGTERM-triggered shutdown must simply
+        # let it finish. If instead the launch manager cancels that transition, the
+        # main process group logs a "kInTransition -> kCancelled" transition after
+        # the SIGTERM was received. That must not happen. (The only legitimate
+        # cancellation - the Startup -> run_target_a switch - happens before the
+        # SIGTERM, so scoping the check to after the SIGTERM marker excludes it.)
+        output = proc.get_output()
+        if isinstance(output, bytes):
+            output = output.decode(errors="replace")
+
+        sigterm_marker = "received SIGTERM"
+        marker_index = output.find(sigterm_marker)
+        assert marker_index != -1, (
+            f"Launch manager never logged receiving the SIGTERM.\nOutput:\n{output}"
+        )
+        output_after_sigterm = output[marker_index:]
+
+        cancelled_lines = [
+            line
+            for line in output_after_sigterm.splitlines()
+            if "to kCancelled" in line and "MainPG" in line
+        ]
+        assert not cancelled_lines, (
+            "The explicit switch to Off was cancelled and redone by the launch "
+            "manager during shutdown instead of being continued. Offending log "
+            "line(s):\n" + "\n".join(cancelled_lines) + "\n\n"
+            f"Full launch manager output after SIGTERM:\n{output_after_sigterm}"
+        )
+    finally:
+        if proc.is_running():
+            proc.stop()
+
+    # component_a is force-terminated (SIGKILLed) during shutdown (its stall
+    # outlives the launch manager's fixed shutdown grace period), so it does not
+    # produce an XML result and is intentionally not asserted here. control_client
+    # is stopped gracefully as part of the switch to Off and produces its result.
+    assert_test_results({"control_client_mock.xml"})

From d555b8cfd2504013386bfb2cc03932cd1f943073 Mon Sep 17 00:00:00 2001
From: Timo Steuerwald <stt1rlz@bosch.com>
Date: Tue, 11 Aug 2026 16:21:30 +0200
Subject: [PATCH 02/23] Add crashdump support in docker environment

---
 .bazelrc                           |   2 +
 tests/integration/readme.md        |  71 +++++++++++++++
 tests/utils/bazel/integration.bzl  |   7 +-
 tests/utils/plugins/integration.py | 140 +++++++++++++++++++++++++++++
 4 files changed, 218 insertions(+), 2 deletions(-)

diff --git a/.bazelrc b/.bazelrc
index 2a35375ed..c5c061d29 100644
--- a/.bazelrc
+++ b/.bazelrc
@@ -72,6 +72,8 @@ build:x86_64-linux --extra_toolchains=@score_toolchains_rust//toolchains/ferroce
 
 test:x86_64-linux --//config:integration_mode=docker
 test:x86_64-linux --//config:unit_mode=host
+# Show a failing test's log (incl. the crash-dump banner) in the console.
+test:x86_64-linux --test_output=errors
 
 # Target configuration for CPU:AArch64|OS:Linux build (do not use it in case of system toolchains!)
 build:arm64-linux --config=stub
diff --git a/tests/integration/readme.md b/tests/integration/readme.md
index 92d514dd3..46c0a8e2e 100644
--- a/tests/integration/readme.md
+++ b/tests/integration/readme.md
@@ -23,3 +23,74 @@ Currently the following configs are supported:
 - `host`
 - `x86_64-linux`
 
+## Crash dumps (core dumps)
+
+When a binary under test (e.g. the launch manager) crashes with `SIGSEGV`,
+`SIGABRT`, etc. inside the Docker sandbox, a core dump is captured
+automatically. This is wired in commonly for every `integration_test`, so
+individual tests need no changes.
+
+How it works:
+- The sandbox container runs privileged with an unlimited core-file `ulimit`.
+- A shared fixture sets the kernel `core_pattern` to a sandbox-local path
+  (`/tmp/score_cores/core.%e.%p.%s.%t`), copies any core dumps produced during
+  the test into the Bazel test outputs, and then restores the original
+  `core_pattern`.
+
+### Getting a crash dump
+
+Run the (crashing) test, disabling the cache so it actually executes:
+```
+bazel test //tests/integration/<test> --config=x86_64-linux --nocache_test_results
+```
+
+If a crash dump was created, a `CRASH DUMP` section is printed right under the
+pytest `FAILURES` section at the end of the run (the `x86_64-linux` config
+enables `--test_output=errors`, so the failing log is shown automatically):
+```
+=================================== FAILURES ===================================
+...
+================================== CRASH DUMP ==================================
+CRASH DUMP HAS BEEN CREATED! See <.../test.outputs/cores> for details.
+
+To open it in gdb (build the crashing binary with -c dbg for symbols):
+    gdb <.../bin/.../launch_manager> "<.../test.outputs/cores/core.launch_manager.*>"
+=========================== short test summary info ============================
+```
+The printed paths are absolute and copy-pasteable. Core files are named
+`core.<exe>.<pid>.<signal>.<time>` (signal `11` = `SIGSEGV`); they are only
+produced on an actual crash and can be large (hundreds of MB).
+
+### Analysing a crash dump
+
+`fastbuild` binaries carry limited symbols; build with `-c dbg` for a usable
+backtrace:
+```
+bazel build //score/launch_manager --config=x86_64-linux -c dbg
+gdb bazel-out/k8-fastbuild/bin/score/launch_manager/src/daemon/launch_manager \
+    "$(bazel info bazel-testlogs)/tests/integration/<test>/<test>/test.outputs/cores/"core.launch_manager.*
+# (gdb) bt
+```
+
+### Important: the `core_pattern` is a global kernel setting
+
+`core_pattern` is **not** namespaced per container - it is shared with the
+host. The fixture therefore changes it globally at the start of a test and
+restores the original value on teardown. Two consequences:
+
+- **Run one crashing target at a time when investigating.** Concurrent tests
+  race on the shared `core_pattern`, so a parallel run can miss dumps or leave
+  a stale value.
+- **If a run is force-killed before teardown**, the restore may not run and
+  `core_pattern` is left pointing at `/tmp/score_cores/...`. Check and restore
+  it manually:
+  ```
+  cat /proc/sys/kernel/core_pattern
+  # On WSL, restore the default handler:
+  docker run --rm --privileged debian:bookworm-slim \
+    bash -c 'echo "|/wsl-capture-crash %t %E %p %s" > /proc/sys/kernel/core_pattern'
+  ```
+  The default `core_pattern` differs per system (e.g. `|/wsl-capture-crash ...`
+  on WSL, `|/lib/systemd/systemd-coredump ...` on systemd hosts, or plain
+  `core`). Check yours *before* the first run so you know the value to restore.
+
diff --git a/tests/utils/bazel/integration.bzl b/tests/utils/bazel/integration.bzl
index be754b194..d0d1ae7f1 100644
--- a/tests/utils/bazel/integration.bzl
+++ b/tests/utils/bazel/integration.bzl
@@ -101,11 +101,14 @@ def integration_test(
             "--local-dir=/tmp/score_itf_host/{}".format(name),
         ],
     })
-    final_plugins = ["//tests/utils/plugins:integration_plugin"] + select({
+    # integration_plugin is listed last so pytest registers it after the
+    # target plugin: its docker_configuration fixture then overrides the
+    # score_itf default (last-registered -p plugin wins fixture overrides).
+    final_plugins = select({
         "//config:integration_docker": ["@score_itf//score/itf/plugins:docker_plugin"],
         "//config:integration_qemu": ["@score_itf//score/itf/plugins:qemu_plugin"],
         "//config:integration_host": ["//tests/utils/plugins:localhost_plugin"],
-    })
+    }) + ["//tests/utils/plugins:integration_plugin"]
 
     # The QEMU plugin uses a hardcoded port so we can only run one test at a time.
     # See https://github.com/eclipse-score/itf/issues/125.
diff --git a/tests/utils/plugins/integration.py b/tests/utils/plugins/integration.py
index 89bf90747..3fcf28da1 100644
--- a/tests/utils/plugins/integration.py
+++ b/tests/utils/plugins/integration.py
@@ -10,11 +10,25 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 # *******************************************************************************
+import logging
 import os
+import re
+import shlex
 from pathlib import Path
 
 import pytest
 
+from score.itf.plugins.core import determine_target_scope
+
+logger = logging.getLogger(__name__)
+
+# Sandbox-local directory a crashing process writes its core dump to, plus the
+# core_pattern that routes cores there. core_pattern is a global (non-namespaced)
+# kernel setting, so it is written from inside the privileged container and
+# restored on teardown - the host is not modified permanently.
+CORE_DUMP_DIR = "/tmp/score_cores"
+CORE_PATTERN = f"{CORE_DUMP_DIR}/core.%e.%p.%s.%t"
+
 
 def pytest_addoption(parser):
     parser.addoption(
@@ -43,6 +57,132 @@ def test_output_dir() -> Path:
     return Path(os.environ["TEST_UNDECLARED_OUTPUTS_DIR"])
 
 
+@pytest.fixture(scope=determine_target_scope)
+def docker_configuration():
+    """Run the test container privileged with an unlimited core-file ulimit so
+    crashing processes produce core dumps inside the sandbox.
+
+    Overrides the score_itf default (empty dict). Privileged is required because
+    core_pattern can only be written from a privileged container; the core
+    ulimit is inherited by every ``docker exec``ed process (e.g. the launch
+    manager under test)."""
+    import docker  # imported lazily: only the docker target has this dependency
+
+    return {
+        "privileged": True,
+        "ulimits": [docker.types.Ulimit(name="core", soft=-1, hard=-1)],
+    }
+
+
+# Crashing exe name (core_pattern %e, i.e. the process comm truncated to 15
+# chars) -> path of the built binary under the Bazel output tree, used to
+# suggest a ready-to-run gdb command. Extend this map as needed.
+_GDB_BINARIES = {
+    "launch_manager": "bin/score/launch_manager/src/daemon/launch_manager",
+}
+
+
+def _persistent_outputs_dir(undeclared: str) -> str:
+    """Translate the in-sandbox TEST_UNDECLARED_OUTPUTS_DIR into the persistent
+    path Bazel copies the outputs to (drops the ``.../sandbox/<type>/<n>/``
+    segment) so the reported paths survive the test and are copy-pasteable."""
+    return re.sub(r"/sandbox/[^/]+/\d+/execroot/", "/execroot/", undeclared)
+
+
+def _core_dump_report_lines(names, cores_dir: str):
+    """Build the crash-dump banner body: the cores location plus a ready-to-run
+    gdb command per core dump."""
+    m = re.search(r"^(.*)/bazel-out/([^/]+)/", cores_dir)
+    out_root = m.group(1) if m else ""
+    config = m.group(2) if m else "k8-fastbuild"
+
+    lines = [
+        f"CRASH DUMP HAS BEEN CREATED! See {cores_dir} for details.",
+        "",
+        "To open it in gdb (build the crashing binary with -c dbg for symbols):",
+    ]
+    for name in names:
+        exe = name.split(".")[1] if name.count(".") >= 1 else name
+        rel = _GDB_BINARIES.get(exe)
+        binary = f"{out_root}/bazel-out/{config}/{rel}" if rel else "<path-to-binary>"
+        lines.append(f'    gdb {binary} "{cores_dir}/{name}"')
+    return lines
+
+
+def _collect_core_dumps(target, test_output_dir: Path):
+    """Download any core dumps produced in the sandbox into the Bazel test
+    outputs; return the list of downloaded core-dump names."""
+    rc, out = target.execute(f"ls -1 {CORE_DUMP_DIR} 2>/dev/null")
+    if rc != 0:
+        return []
+    names = [n for n in out.decode(errors="replace").split() if n]
+    if not names:
+        return []
+    dest_dir = Path(test_output_dir) / "cores"
+    dest_dir.mkdir(parents=True, exist_ok=True)
+    downloaded = []
+    for name in names:
+        try:
+            target.download(f"{CORE_DUMP_DIR}/{name}", str(dest_dir / name))
+            downloaded.append(name)
+        except Exception:
+            logger.warning(f"Failed to download core dump {name}", exc_info=True)
+    return downloaded
+
+
+@pytest.fixture(autouse=True)
+def _capture_core_dumps(request, target, test_output_dir):
+    """Route core dumps to a sandbox-local directory for the duration of the
+    test, collect any that were produced, then restore the original
+    core_pattern.
+
+    Only active for the Docker sandbox. core_pattern is a global kernel setting,
+    so it is set from inside the privileged container and reverted afterwards
+    (the "container-local + auto-restore" strategy)."""
+    if request.config.getoption("docker_image", default=None) is None:
+        yield  # not the docker sandbox; nothing to capture
+        return
+
+    rc, out = target.execute("cat /proc/sys/kernel/core_pattern")
+    original = out.decode(errors="replace").strip("\n") if rc == 0 else None
+
+    rc, _ = target.execute(
+        f"mkdir -p {CORE_DUMP_DIR} && chmod 0777 {CORE_DUMP_DIR} && "
+        f"printf '%s' {shlex.quote(CORE_PATTERN)} > /proc/sys/kernel/core_pattern"
+    )
+    enabled = rc == 0
+    if not enabled:
+        logger.warning("Could not enable sandbox core dumps (core_pattern write failed)")
+
+    try:
+        yield
+    finally:
+        try:
+            downloaded = _collect_core_dumps(target, test_output_dir)
+            if downloaded:
+                cores_dir = f"{_persistent_outputs_dir(str(test_output_dir))}/cores"
+                banners = getattr(request.config, "_score_core_dump_banners", [])
+                banners.append(_core_dump_report_lines(downloaded, cores_dir))
+                request.config._score_core_dump_banners = banners
+        finally:
+            if enabled and original is not None:
+                target.execute(
+                    f"printf '%s' {shlex.quote(original)} > /proc/sys/kernel/core_pattern"
+                )
+
+
+def pytest_terminal_summary(terminalreporter, exitstatus, config):
+    """Print the crash-dump banner(s) after the FAILURES section, so the pointer
+    to each core dump and its gdb command is the last thing shown."""
+    banners = getattr(config, "_score_core_dump_banners", None)
+    if not banners:
+        return
+    for lines in banners:
+        terminalreporter.write_sep("=", "CRASH DUMP", red=True, bold=True)
+        for line in lines:
+            terminalreporter.write_line(line)
+
+
 def pytest_configure(config):
     binary_path = config.getoption("--score-test-binary-path", default=None)
     if binary_path is not None:

From df7fc18410a73534724f535a7b7691eaea3f8465 Mon Sep 17 00:00:00 2001
From: Timo Steuerwald <stt1rlz@bosch.com>
Date: Wed, 12 Aug 2026 16:11:30 +0200
Subject: [PATCH 03/23] Log PID

---
 .../lm_shutdown_during_switch_to_off/component_a.cpp      | 8 ++++++--
 .../control_client_mock.cpp                               | 7 +++++--
 2 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/tests/integration/lm_shutdown_during_switch_to_off/component_a.cpp b/tests/integration/lm_shutdown_during_switch_to_off/component_a.cpp
index 26b9633eb..6fac078e4 100644
--- a/tests/integration/lm_shutdown_during_switch_to_off/component_a.cpp
+++ b/tests/integration/lm_shutdown_during_switch_to_off/component_a.cpp
@@ -36,15 +36,19 @@ namespace
 /// It must also be smaller than component_a's configured shutdown_timeout so the
 /// STOP job does not SIGKILL it on its own before the launch manager SIGTERM is
 /// handled (which would end the switch to Off early and defeat the test).
-constexpr unsigned int kTerminationDelaySeconds = 2U;
+constexpr unsigned int kTerminationDelaySeconds = 5U;
 }  // namespace
 
 TEST(LmShutdownDuringSwitchToOff, ComponentA)
 {
-    TEST_STEP("Report running")
+    const auto pid = getpid();
+    const std::string step_msg = "Report running with pid == " + std::to_string(pid);
+
+    TEST_STEP(step_msg)
     {
         EXPECT_TRUE(touch_file(a_started)) << "failed to deploy file";
         score::mw::lifecycle::report_running();
+        FAIL() << "component_a should not be running after the launch manager has been SIGTERMed";
     }
 
     // Wait until the launch manager asks us to terminate (SIGTERM), which happens
diff --git a/tests/integration/lm_shutdown_during_switch_to_off/control_client_mock.cpp b/tests/integration/lm_shutdown_during_switch_to_off/control_client_mock.cpp
index 8648d6a59..bc4650340 100644
--- a/tests/integration/lm_shutdown_during_switch_to_off/control_client_mock.cpp
+++ b/tests/integration/lm_shutdown_during_switch_to_off/control_client_mock.cpp
@@ -38,7 +38,10 @@ TEST(LmShutdownDuringSwitchToOff, ControlClient)
     score::mw::lifecycle::ControlClient client{};
     ASSERT_TRUE(check_clean({test_end_location, a_started, a_terminating}));
 
-    TEST_STEP("Report running")
+    const auto pid = getpid();
+    const std::string step_msg = "Report running with pid == " + std::to_string(pid);
+
+    TEST_STEP(step_msg)
     {
         score::mw::lifecycle::report_running();
     }
@@ -70,5 +73,5 @@ TEST(LmShutdownDuringSwitchToOff, ControlClient)
 
 int main()
 {
-    return TestRunner(__FILE__, TerminationBehavior::kWait, TerminationNotification::kTestEnd).RunTests();
+    return TestRunner(__FILE__, TerminationBehavior::kContinue, TerminationNotification::kTestEnd).RunTests();
 }

From f47e90ae66ace112707145fdaf4c63b8bed43bf6 Mon Sep 17 00:00:00 2001
From: Timo Steuerwald <stt1rlz@bosch.com>
Date: Wed, 12 Aug 2026 18:31:08 +0200
Subject: [PATCH 04/23] Proposed fix by Claude.

---
 .../daemon/src/process_group_manager/process_group_manager.cpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/score/launch_manager/src/daemon/src/process_group_manager/process_group_manager.cpp b/score/launch_manager/src/daemon/src/process_group_manager/process_group_manager.cpp
index 1d1cd679a..892ba1a4e 100644
--- a/score/launch_manager/src/daemon/src/process_group_manager/process_group_manager.cpp
+++ b/score/launch_manager/src/daemon/src/process_group_manager/process_group_manager.cpp
@@ -245,6 +245,7 @@ bool ProcessGroupManager::initializeProcessGroups()
             const uint32_t num_run_targets = states ? static_cast<uint32_t>(states->size()) : 0U;
 
             process_groups_.push_back(
+
                 std::make_shared<Graph>(
                     num_processes + num_run_targets,
                     &configuration_,
@@ -477,6 +478,8 @@ void ProcessGroupManager::allProcessGroupsOff()
         {
             pg->forceKillProcesses();
         }
+
+        thread_pool_.reset();
     }
 }
 

From 26d29dbafdc6285521b805169efe04e399f2e1cb Mon Sep 17 00:00:00 2001
From: Timo Steuerwald <stt1rlz@bosch.com>
Date: Wed, 12 Aug 2026 18:45:30 +0200
Subject: [PATCH 05/23] Increase shutdown_timeout

---
 .../lm_shutdown_during_switch_to_off.json                       | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/integration/lm_shutdown_during_switch_to_off/lm_shutdown_during_switch_to_off.json b/tests/integration/lm_shutdown_during_switch_to_off/lm_shutdown_during_switch_to_off.json
index b1b9beafa..2c460da3d 100644
--- a/tests/integration/lm_shutdown_during_switch_to_off/lm_shutdown_during_switch_to_off.json
+++ b/tests/integration/lm_shutdown_during_switch_to_off/lm_shutdown_during_switch_to_off.json
@@ -54,7 +54,7 @@
             },
             "deployment_config": {
                 "ready_timeout": 1.0,
-                "shutdown_timeout": 1.0,
+                "shutdown_timeout": 5.0,
                 "environmental_variables": {
                     "PROCESSIDENTIFIER": "control_client_mock"
                 }

From d01df84fd51adcca7791e9720233c929f64d0179 Mon Sep 17 00:00:00 2001
From: Timo Steuerwald <stt1rlz@bosch.com>
Date: Wed, 12 Aug 2026 18:45:42 +0200
Subject: [PATCH 06/23] Revert FAIL

---
 .../integration/lm_shutdown_during_switch_to_off/component_a.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/tests/integration/lm_shutdown_during_switch_to_off/component_a.cpp b/tests/integration/lm_shutdown_during_switch_to_off/component_a.cpp
index 6fac078e4..9d084b802 100644
--- a/tests/integration/lm_shutdown_during_switch_to_off/component_a.cpp
+++ b/tests/integration/lm_shutdown_during_switch_to_off/component_a.cpp
@@ -48,7 +48,6 @@ TEST(LmShutdownDuringSwitchToOff, ComponentA)
     {
         EXPECT_TRUE(touch_file(a_started)) << "failed to deploy file";
         score::mw::lifecycle::report_running();
-        FAIL() << "component_a should not be running after the launch manager has been SIGTERMed";
     }
 
     // Wait until the launch manager asks us to terminate (SIGTERM), which happens

From b077c926d57e97942b7e81ea3e66c5fa1e80f975 Mon Sep 17 00:00:00 2001
From: Timo Steuerwald <stt1rlz@bosch.com>
Date: Thu, 13 Aug 2026 10:03:13 +0200
Subject: [PATCH 07/23] Honor the termination timeout during shutdown

---
 .../configuration/configuration_adapter.cpp   | 13 ++++++++
 .../configuration/configuration_adapter.hpp   |  4 +++
 .../process_group_manager.cpp                 | 15 +++++++--
 .../process_group_manager.hpp                 |  3 +-
 .../component_a.cpp                           | 33 +++++++++----------
 .../control_client_mock.cpp                   |  8 +++--
 .../lm_shutdown_during_switch_to_off.py       | 29 +++++++---------
 7 files changed, 65 insertions(+), 40 deletions(-)

diff --git a/score/launch_manager/src/daemon/src/configuration/configuration_adapter.cpp b/score/launch_manager/src/daemon/src/configuration/configuration_adapter.cpp
index 20564194b..568ed2674 100644
--- a/score/launch_manager/src/daemon/src/configuration/configuration_adapter.cpp
+++ b/score/launch_manager/src/daemon/src/configuration/configuration_adapter.cpp
@@ -429,6 +429,19 @@ std::optional<uint32_t> ConfigurationAdapter::getNumberOfOsProcesses(const Ident
     return std::nullopt;
 }
 
+std::chrono::milliseconds ConfigurationAdapter::getMaxTerminationTimeout() const
+{
+    std::chrono::milliseconds max_timeout{0};
+    for (const auto& pg : process_groups_)
+    {
+        for (const auto& process : pg.processes_)
+        {
+            max_timeout = std::max(max_timeout, process.pgm_config_.termination_timeout_ms_);
+        }
+    }
+    return max_timeout;
+}
+
 IdentifierHash ConfigurationAdapter::getNameOfOffState(const IdentifierHash& pg_name) const
 {
     auto pg = getProcessGroupByID(pg_name);
diff --git a/score/launch_manager/src/daemon/src/configuration/configuration_adapter.hpp b/score/launch_manager/src/daemon/src/configuration/configuration_adapter.hpp
index 9cc87683d..e1c1ef8cb 100644
--- a/score/launch_manager/src/daemon/src/configuration/configuration_adapter.hpp
+++ b/score/launch_manager/src/daemon/src/configuration/configuration_adapter.hpp
@@ -88,6 +88,10 @@ class ConfigurationAdapter final
     std::optional<const std::vector<IdentifierHash>*> getListOfProcessGroups() const;
     std::optional<IdentifierHash> getSoftwareCluster(const IdentifierHash& process_group_id) const;
     std::optional<uint32_t> getNumberOfOsProcesses(const IdentifierHash& pg_name) const;
+    /// @brief Largest per-process shutdown_timeout (termination_timeout_ms_) across all configured
+    /// processes, or zero if none are configured. Used to bound the wait for the shutdown transition
+    /// to Off while still honouring each process's individual shutdown_timeout.
+    std::chrono::milliseconds getMaxTerminationTimeout() const;
     IdentifierHash getNameOfOffState(const IdentifierHash& pg_name) const;
     IdentifierHash getNameOfRecoveryState(const IdentifierHash& pg_name) const;
     std::optional<const score::mw::lifecycle::internal::ProcessGroupStateID*> getMainPGStartupState() const;
diff --git a/score/launch_manager/src/daemon/src/process_group_manager/process_group_manager.cpp b/score/launch_manager/src/daemon/src/process_group_manager/process_group_manager.cpp
index 892ba1a4e..42b8486b9 100644
--- a/score/launch_manager/src/daemon/src/process_group_manager/process_group_manager.cpp
+++ b/score/launch_manager/src/daemon/src/process_group_manager/process_group_manager.cpp
@@ -469,8 +469,19 @@ void ProcessGroupManager::allProcessGroupsOff()
     }
 
     LM_LOG_DEBUG() << "Wait for all process groups to complete the transition";
-    if (!waitForStateCompletion(GraphState::kInTransition, 1000))
-    {
+
+    // Each worker deactivating a process already honours that process's configured
+    // shutdown_timeout: it sends SIGTERM, waits up to termination_timeout_ms_ for a
+    // graceful exit and only then SIGKILLs (waiting a further kMaxSigKillDelay).
+    // Bound the wait for the whole transition to Off by the slowest such process
+    // rather than a fixed grace period, so every component's shutdown_timeout is
+    // respected. Processes deactivate in parallel, so the largest per-process
+    // timeout (plus the SIGKILL grace) bounds how long the transition can take.
+    const auto off_transition_timeout = configuration_.getMaxTerminationTimeout() + kMaxSigKillDelay;
+    if (!waitForStateCompletion(GraphState::kInTransition, static_cast<int32_t>(off_transition_timeout.count())))
+    {
+        // Last resort: a process ignored even SIGKILL within its budget. Force-kill
+        // whatever is left and tear down the worker pool so shutdown can still proceed.
         LM_LOG_ERROR() << "NOTE: Transition to Off state timed out";
         thread_pool_->stop();
 
diff --git a/score/launch_manager/src/daemon/src/process_group_manager/process_group_manager.hpp b/score/launch_manager/src/daemon/src/process_group_manager/process_group_manager.hpp
index fdb998869..33cde73da 100644
--- a/score/launch_manager/src/daemon/src/process_group_manager/process_group_manager.hpp
+++ b/score/launch_manager/src/daemon/src/process_group_manager/process_group_manager.hpp
@@ -259,7 +259,8 @@ class ProcessGroupManager final : public ITransitionResultPublisher
     /// @brief Send all process groups to the "Off" state
     /// @details cancel any Graph for a process group not in the "Off" state, wait for up to 2 seconds for all graphs
     /// to be no longer in the `kCancelled` state, start a transition of remaining process groups to "Off" state,
-    /// and finally wait for up to a second for all graphs to complete.
+    /// and finally wait for all graphs to complete. The final wait is bounded by the largest configured per-process
+    /// shutdown_timeout (plus the SIGKILL grace) so each component's individual shutdown_timeout is respected.
     /// @warning Side effect: Depending if it is needed to forcefully terminate processes, worker jobs might be stopped
     /// after this call
     void allProcessGroupsOff();
diff --git a/tests/integration/lm_shutdown_during_switch_to_off/component_a.cpp b/tests/integration/lm_shutdown_during_switch_to_off/component_a.cpp
index 9d084b802..95fb1575d 100644
--- a/tests/integration/lm_shutdown_during_switch_to_off/component_a.cpp
+++ b/tests/integration/lm_shutdown_during_switch_to_off/component_a.cpp
@@ -12,6 +12,8 @@
  ********************************************************************************/
 #include <gtest/gtest.h>
 #include <unistd.h>
+#include <chrono>
+#include <thread>
 
 #include "common.hpp"
 #include "tests/utils/test_helper/test_helper.hpp"
@@ -19,24 +21,18 @@
 
 namespace
 {
-/// @brief How long component_a stalls while it is being terminated. During a
-/// run-target switch the launch manager runs the STOP phase (terminating
-/// no-longer-needed processes) fully before the START phase (activating newly
-/// needed processes). By stalling here, component_a keeps the switch (to the
-/// "Off" run target) in the STOP phase, giving the test a deterministic window
-/// to send SIGTERM to the launch manager while the switch to Off is still in
-/// progress.
+/// @brief How long component_a stalls while it is being terminated. By stalling here, component_a keeps the switch (to
+/// the "Off" run target) in the STOP phase, giving the test a deterministic window to send SIGTERM to the launch
+/// manager while the switch to Off is still in progress.
 ///
 /// It must be comfortably larger than the time the test needs to observe
-/// `a_terminating` and deliver the SIGTERM to the launch manager AND larger than
-/// the launch manager's fixed shutdown grace period (see the NOTE in
-/// ProcessGroupManager::allProcessGroupsOff): the shutdown does NOT respect the
-/// per-process shutdown_timeout, so this stall outlives that grace period and
-/// component_a is force-terminated (SIGKILLed) - it does not write an XML result.
-/// It must also be smaller than component_a's configured shutdown_timeout so the
-/// STOP job does not SIGKILL it on its own before the launch manager SIGTERM is
-/// handled (which would end the switch to Off early and defeat the test).
-constexpr unsigned int kTerminationDelaySeconds = 5U;
+/// `a_terminating` and deliver the SIGTERM to the launch manager, so the switch
+/// to Off is still in progress when that SIGTERM arrives. It must also be
+/// comfortably smaller than component_a's configured shutdown_timeout: the launch
+/// manager honours that per-process shutdown_timeout during its own shutdown, so
+/// component_a is given time to exit on its own and terminates gracefully (and
+/// writes its XML result) rather than being force-terminated (SIGKILLed).
+constexpr unsigned int kTerminationDelaySeconds = 2U;
 }  // namespace
 
 TEST(LmShutdownDuringSwitchToOff, ComponentA)
@@ -52,9 +48,12 @@ TEST(LmShutdownDuringSwitchToOff, ComponentA)
 
     // Wait until the launch manager asks us to terminate (SIGTERM), which happens
     // when the switch away from run_target_a (to the "Off" run target) begins.
+    // Poll the flag rather than pause(): a process-directed SIGTERM may be handled
+    // on a background thread (e.g. alive reporting), which would set exitRequested
+    // without waking a main thread blocked in pause().
     while (!TestRunner::exitRequested)
     {
-        pause();
+        std::this_thread::sleep_for(std::chrono::milliseconds(10));
     }
 
     TEST_STEP("Stall during termination to keep the run-target switch in progress")
diff --git a/tests/integration/lm_shutdown_during_switch_to_off/control_client_mock.cpp b/tests/integration/lm_shutdown_during_switch_to_off/control_client_mock.cpp
index bc4650340..e5e5d5409 100644
--- a/tests/integration/lm_shutdown_during_switch_to_off/control_client_mock.cpp
+++ b/tests/integration/lm_shutdown_during_switch_to_off/control_client_mock.cpp
@@ -12,7 +12,9 @@
  ********************************************************************************/
 #include <gtest/gtest.h>
 #include <unistd.h>
+#include <chrono>
 #include <filesystem>
+#include <thread>
 
 #include "common.hpp"
 #include "tests/utils/test_helper/test_helper.hpp"
@@ -64,10 +66,12 @@ TEST(LmShutdownDuringSwitchToOff, ControlClient)
     }
 
     // Block until the launch manager terminates us as part of the switch to Off /
-    // its own shutdown.
+    // its own shutdown. Poll the flag rather than pause(): a process-directed
+    // SIGTERM may be handled on one of the control client's background threads,
+    // which would set exitRequested without waking a main thread blocked in pause().
     while (!TestRunner::exitRequested)
     {
-        pause();
+        std::this_thread::sleep_for(std::chrono::milliseconds(10));
     }
 }
 
diff --git a/tests/integration/lm_shutdown_during_switch_to_off/lm_shutdown_during_switch_to_off.py b/tests/integration/lm_shutdown_during_switch_to_off/lm_shutdown_during_switch_to_off.py
index bc7c7e14d..a68c72c73 100644
--- a/tests/integration/lm_shutdown_during_switch_to_off/lm_shutdown_during_switch_to_off.py
+++ b/tests/integration/lm_shutdown_during_switch_to_off/lm_shutdown_during_switch_to_off.py
@@ -94,19 +94,12 @@ def test_lm_shutdown(
     continue - it must NOT cancel the explicit switch to Off and redo it - all the
     processes it owns are stopped, and it exits cleanly.
 
-    NOTE: the launch manager does NOT respect the per-process shutdown_timeout
-    during its own shutdown (see the NOTE in ProcessGroupManager::
-    allProcessGroupsOff). It applies a single fixed grace period to the whole
-    in-progress transition, after which any process still terminating is
-    force-terminated (SIGKILLed). component_a deliberately stalls past that grace
-    period, so it is SIGKILLed and does NOT produce an XML result - this test
-    therefore does not assert on component_a's XML.
-
-    Note: this test currently FAILS. It documents a launch manager defect: on
-    SIGTERM, allProcessGroupsOff() unconditionally cancels every process group -
-    including one that is already transitioning to Off - and then restarts the
-    transition to Off, instead of letting the in-progress switch to Off continue.
-    The test passes once that defect is fixed.
+    The launch manager honours each component's individual shutdown_timeout during
+    its own shutdown: it waits for the in-progress transition to Off to complete,
+    giving every process up to its configured shutdown_timeout to exit before it
+    would be force-terminated. component_a stalls for less than its shutdown_timeout
+    while it is being terminated, so it is given time to exit on its own and
+    terminates gracefully (producing its XML result) rather than being SIGKILLed.
     """
 
     new_config_path = str(remote_test_dir / "etc/lm_shutdown_during_switch_to_off.bin")
@@ -189,8 +182,8 @@ def test_lm_shutdown(
         if proc.is_running():
             proc.stop()
 
-    # component_a is force-terminated (SIGKILLed) during shutdown (its stall
-    # outlives the launch manager's fixed shutdown grace period), so it does not
-    # produce an XML result and is intentionally not asserted here. control_client
-    # is stopped gracefully as part of the switch to Off and produces its result.
-    assert_test_results({"control_client_mock.xml"})
+    # Both components are stopped gracefully as part of the switch to Off and
+    # produce their XML results: control_client is terminated when the switch to
+    # Off begins, and component_a exits within its shutdown_timeout (which the
+    # launch manager honours) instead of being force-terminated.
+    assert_test_results({"control_client_mock.xml", "component_a.xml"})

From d47eec14419c98719196c76528ff927b18a0ec02 Mon Sep 17 00:00:00 2001
From: Timo Steuerwald <stt1rlz@bosch.com>
Date: Thu, 13 Aug 2026 12:04:18 +0200
Subject: [PATCH 08/23] Add method to TestRunner

Other ControlClientMocks need to be updated separately.
---
 .../component_a.cpp                           |  7 +----
 .../control_client_mock.cpp                   | 12 ++------
 tests/utils/test_helper/test_helper.hpp       | 28 +++++++++++++++++++
 3 files changed, 32 insertions(+), 15 deletions(-)

diff --git a/tests/integration/lm_shutdown_during_switch_to_off/component_a.cpp b/tests/integration/lm_shutdown_during_switch_to_off/component_a.cpp
index 95fb1575d..4fe0fce87 100644
--- a/tests/integration/lm_shutdown_during_switch_to_off/component_a.cpp
+++ b/tests/integration/lm_shutdown_during_switch_to_off/component_a.cpp
@@ -12,8 +12,6 @@
  ********************************************************************************/
 #include <gtest/gtest.h>
 #include <unistd.h>
-#include <chrono>
-#include <thread>
 
 #include "common.hpp"
 #include "tests/utils/test_helper/test_helper.hpp"
@@ -48,12 +46,9 @@ TEST(LmShutdownDuringSwitchToOff, ComponentA)
 
     // Wait until the launch manager asks us to terminate (SIGTERM), which happens
     // when the switch away from run_target_a (to the "Off" run target) begins.
-    // Poll the flag rather than pause(): a process-directed SIGTERM may be handled
-    // on a background thread (e.g. alive reporting), which would set exitRequested
-    // without waking a main thread blocked in pause().
     while (!TestRunner::exitRequested)
     {
-        std::this_thread::sleep_for(std::chrono::milliseconds(10));
+        pause();
     }
 
     TEST_STEP("Stall during termination to keep the run-target switch in progress")
diff --git a/tests/integration/lm_shutdown_during_switch_to_off/control_client_mock.cpp b/tests/integration/lm_shutdown_during_switch_to_off/control_client_mock.cpp
index e5e5d5409..f14acf842 100644
--- a/tests/integration/lm_shutdown_during_switch_to_off/control_client_mock.cpp
+++ b/tests/integration/lm_shutdown_during_switch_to_off/control_client_mock.cpp
@@ -12,9 +12,7 @@
  ********************************************************************************/
 #include <gtest/gtest.h>
 #include <unistd.h>
-#include <chrono>
 #include <filesystem>
-#include <thread>
 
 #include "common.hpp"
 #include "tests/utils/test_helper/test_helper.hpp"
@@ -66,13 +64,9 @@ TEST(LmShutdownDuringSwitchToOff, ControlClient)
     }
 
     // Block until the launch manager terminates us as part of the switch to Off /
-    // its own shutdown. Poll the flag rather than pause(): a process-directed
-    // SIGTERM may be handled on one of the control client's background threads,
-    // which would set exitRequested without waking a main thread blocked in pause().
-    while (!TestRunner::exitRequested)
-    {
-        std::this_thread::sleep_for(std::chrono::milliseconds(10));
-    }
+    // its own shutdown. See waitForTermination(): the ControlClient's background
+    // thread means we must not wait with a bare pause().
+    TestRunner::waitForTermination();
 }
 
 int main()
diff --git a/tests/utils/test_helper/test_helper.hpp b/tests/utils/test_helper/test_helper.hpp
index 569ec7f1b..ca29dd7f2 100644
--- a/tests/utils/test_helper/test_helper.hpp
+++ b/tests/utils/test_helper/test_helper.hpp
@@ -14,9 +14,12 @@
 #define TESTS_UTILS_TEST_HELPER_HPP
 
 #include <gtest/gtest.h>
+#include <atomic>
+#include <chrono>
 #include <filesystem>
 #include <string>
 #include <string_view>
+#include <thread>
 
 /// @return File path to an xml adjacent to the input file path
 inline std::string xmlPath(const std::string_view file)
@@ -166,6 +169,31 @@ class TestRunner
     /// @brief True if the test process has received SIGINT or SIGTERM
     inline static std::atomic<bool> exitRequested = false;
 
+    /// @brief Block the calling (main) thread until the test process is asked to
+    /// terminate (a SIGINT/SIGTERM sets exitRequested via signalHandler).
+    ///
+    /// Poll the atomic flag instead of calling pause() directly. A process-directed
+    /// signal (from kill) is delivered to an arbitrary one of the process's threads
+    /// that has the signal unblocked. If the test process has more than one thread
+    /// (e.g. a ControlClient, whose constructor spawns a background IPC thread), the
+    /// handler may run on a background thread and set exitRequested there. pause()
+    /// only returns for a signal handled on the calling thread, so a main thread
+    /// blocked in pause() would not wake - it would stay parked until the launch
+    /// manager SIGKILLs it at its shutdown_timeout, and never write its XML result.
+    /// Polling observes the flag regardless of which thread handled the signal.
+    ///
+    /// TODO: A GitHub issue shall be created to adopt this helper in the remaining
+    /// tests/integration/*/control_client_mock.cpp binaries, which still wait with a
+    /// bare pause() and are subject to the same race. Kept out of the current PR to
+    /// keep its scope contained.
+    static void waitForTermination()
+    {
+        while (!exitRequested)
+        {
+            std::this_thread::sleep_for(std::chrono::milliseconds(10));
+        }
+    }
+
     /// @brief Use this function in main() to run all tests. It returns 0 if all tests are successful, or 1 otherwise.
     int RunTests()
     {

From 6dfa775065d9e0034235c96dbb19d92a89789d11 Mon Sep 17 00:00:00 2001
From: Timo Steuerwald <stt1rlz@bosch.com>
Date: Thu, 13 Aug 2026 12:26:57 +0200
Subject: [PATCH 09/23] Only check shutdown timeout of currently active
 runtarget

---
 .../src/configuration/configuration_adapter.cpp   | 13 -------------
 .../src/configuration/configuration_adapter.hpp   |  4 ----
 .../src/process_group_manager/details/graph.cpp   | 15 +++++++++++++++
 .../src/process_group_manager/details/graph.hpp   |  5 +++++
 .../details/process_info_node.cpp                 |  5 +++++
 .../details/process_info_node.hpp                 |  5 +++++
 .../process_group_manager.cpp                     |  4 +++-
 7 files changed, 33 insertions(+), 18 deletions(-)

diff --git a/score/launch_manager/src/daemon/src/configuration/configuration_adapter.cpp b/score/launch_manager/src/daemon/src/configuration/configuration_adapter.cpp
index 568ed2674..20564194b 100644
--- a/score/launch_manager/src/daemon/src/configuration/configuration_adapter.cpp
+++ b/score/launch_manager/src/daemon/src/configuration/configuration_adapter.cpp
@@ -429,19 +429,6 @@ std::optional<uint32_t> ConfigurationAdapter::getNumberOfOsProcesses(const Ident
     return std::nullopt;
 }
 
-std::chrono::milliseconds ConfigurationAdapter::getMaxTerminationTimeout() const
-{
-    std::chrono::milliseconds max_timeout{0};
-    for (const auto& pg : process_groups_)
-    {
-        for (const auto& process : pg.processes_)
-        {
-            max_timeout = std::max(max_timeout, process.pgm_config_.termination_timeout_ms_);
-        }
-    }
-    return max_timeout;
-}
-
 IdentifierHash ConfigurationAdapter::getNameOfOffState(const IdentifierHash& pg_name) const
 {
     auto pg = getProcessGroupByID(pg_name);
diff --git a/score/launch_manager/src/daemon/src/configuration/configuration_adapter.hpp b/score/launch_manager/src/daemon/src/configuration/configuration_adapter.hpp
index e1c1ef8cb..9cc87683d 100644
--- a/score/launch_manager/src/daemon/src/configuration/configuration_adapter.hpp
+++ b/score/launch_manager/src/daemon/src/configuration/configuration_adapter.hpp
@@ -88,10 +88,6 @@ class ConfigurationAdapter final
     std::optional<const std::vector<IdentifierHash>*> getListOfProcessGroups() const;
     std::optional<IdentifierHash> getSoftwareCluster(const IdentifierHash& process_group_id) const;
     std::optional<uint32_t> getNumberOfOsProcesses(const IdentifierHash& pg_name) const;
-    /// @brief Largest per-process shutdown_timeout (termination_timeout_ms_) across all configured
-    /// processes, or zero if none are configured. Used to bound the wait for the shutdown transition
-    /// to Off while still honouring each process's individual shutdown_timeout.
-    std::chrono::milliseconds getMaxTerminationTimeout() const;
     IdentifierHash getNameOfOffState(const IdentifierHash& pg_name) const;
     IdentifierHash getNameOfRecoveryState(const IdentifierHash& pg_name) const;
     std::optional<const score::mw::lifecycle::internal::ProcessGroupStateID*> getMainPGStartupState() const;
diff --git a/score/launch_manager/src/daemon/src/process_group_manager/details/graph.cpp b/score/launch_manager/src/daemon/src/process_group_manager/details/graph.cpp
index c503c84ef..e62099bcd 100644
--- a/score/launch_manager/src/daemon/src/process_group_manager/details/graph.cpp
+++ b/score/launch_manager/src/daemon/src/process_group_manager/details/graph.cpp
@@ -14,6 +14,8 @@
 #include <ctime>
 
 #include <score/span.hpp>
+#include <algorithm>
+#include <chrono>
 #include <functional>
 #include <type_traits>
 #include <variant>
@@ -542,6 +544,19 @@ void Graph::forceKillProcesses()
     }
 }
 
+std::chrono::milliseconds Graph::getMaxTerminationTimeout()
+{
+    std::chrono::milliseconds max_timeout{0};
+    for (const auto& component : nodes_)
+    {
+        if (const ProcessInfoNode* process = std::get_if<ProcessInfoNode>(&component))
+        {
+            max_timeout = std::max(max_timeout, process->getTerminationTimeout());
+        }
+    }
+    return max_timeout;
+}
+
 void Graph::updateCancelMessage()
 {
     ControlClientCode code = getPendingEvent();
diff --git a/score/launch_manager/src/daemon/src/process_group_manager/details/graph.hpp b/score/launch_manager/src/daemon/src/process_group_manager/details/graph.hpp
index ba383ed08..aa5872a0a 100644
--- a/score/launch_manager/src/daemon/src/process_group_manager/details/graph.hpp
+++ b/score/launch_manager/src/daemon/src/process_group_manager/details/graph.hpp
@@ -288,6 +288,11 @@ class Graph final
     /// @brief For forced shutdown, kill all leftover processes
     void forceKillProcesses();
 
+    /// @return The largest configured shutdown_timeout (termination_timeout_ms_) across the process
+    /// nodes of this process group, or zero if it has none. Used to bound the wait for the transition
+    /// to Off by the slowest process while still honouring each process's individual shutdown_timeout.
+    std::chrono::milliseconds getMaxTerminationTimeout();
+
   private:
     /// @brief Helper function to identify a node with ready state "Terminated" from the legacy configuration
     bool nodeHasTerminatedDeps(IdentifierHash pg_name, uint32_t node_index);
diff --git a/score/launch_manager/src/daemon/src/process_group_manager/details/process_info_node.cpp b/score/launch_manager/src/daemon/src/process_group_manager/details/process_info_node.cpp
index 806a11d9c..01fd8f347 100644
--- a/score/launch_manager/src/daemon/src/process_group_manager/details/process_info_node.cpp
+++ b/score/launch_manager/src/daemon/src/process_group_manager/details/process_info_node.cpp
@@ -432,6 +432,11 @@ score::mw::lifecycle::ProcessState ProcessInfoNode::getState() const
     return process_state_.load();
 }
 
+std::chrono::milliseconds ProcessInfoNode::getTerminationTimeout() const
+{
+    return config_ != nullptr ? config_->pgm_config_.termination_timeout_ms_ : std::chrono::milliseconds{0};
+}
+
 uint32_t ProcessInfoNode::getIndex() const
 {
     return process_index_;
diff --git a/score/launch_manager/src/daemon/src/process_group_manager/details/process_info_node.hpp b/score/launch_manager/src/daemon/src/process_group_manager/details/process_info_node.hpp
index 8310330a8..dff43b4ac 100644
--- a/score/launch_manager/src/daemon/src/process_group_manager/details/process_info_node.hpp
+++ b/score/launch_manager/src/daemon/src/process_group_manager/details/process_info_node.hpp
@@ -21,6 +21,7 @@
 #include "score/mw/launch_manager/supervision_control_client/isupervision_event_publisher.hpp"
 #include <score/stop_token.hpp>
 #include <atomic>
+#include <chrono>
 
 namespace score::mw::lifecycle::internal
 {
@@ -99,6 +100,10 @@ class ProcessInfoNode final : public IComponent
     /// @return The current state of this process.
     score::mw::lifecycle::ProcessState getState() const;
 
+    /// @return The configured shutdown_timeout (termination_timeout_ms_) for this process, or zero
+    /// if the node has no configuration.
+    std::chrono::milliseconds getTerminationTimeout() const;
+
     /// @return The ControlClientChannel for this process, or nullptr if none exists.
     ControlClientChannelP getControlClientChannel() const;
 
diff --git a/score/launch_manager/src/daemon/src/process_group_manager/process_group_manager.cpp b/score/launch_manager/src/daemon/src/process_group_manager/process_group_manager.cpp
index 42b8486b9..43f538b94 100644
--- a/score/launch_manager/src/daemon/src/process_group_manager/process_group_manager.cpp
+++ b/score/launch_manager/src/daemon/src/process_group_manager/process_group_manager.cpp
@@ -477,7 +477,9 @@ void ProcessGroupManager::allProcessGroupsOff()
     // rather than a fixed grace period, so every component's shutdown_timeout is
     // respected. Processes deactivate in parallel, so the largest per-process
     // timeout (plus the SIGKILL grace) bounds how long the transition can take.
-    const auto off_transition_timeout = configuration_.getMaxTerminationTimeout() + kMaxSigKillDelay;
+    // Scope this to the process nodes of the graph being shut down (its own
+    // process group) rather than the whole configuration.
+    const auto off_transition_timeout = graph.getMaxTerminationTimeout() + kMaxSigKillDelay;
     if (!waitForStateCompletion(GraphState::kInTransition, static_cast<int32_t>(off_transition_timeout.count())))
     {
         // Last resort: a process ignored even SIGKILL within its budget. Force-kill

From f46a63bb2584f6dd4729f0270554fc097c296c04 Mon Sep 17 00:00:00 2001
From: Timo Steuerwald <stt1rlz@bosch.com>
Date: Thu, 13 Aug 2026 13:53:12 +0200
Subject: [PATCH 10/23] Consider only the shutdown timeout of active processes

---
 .../process_group_manager/details/graph.cpp   | 10 ++-
 .../process_group_manager/details/graph.hpp   |  8 ++-
 .../details/graph_UT.cpp                      | 61 +++++++++++++++++++
 .../process_group_manager.cpp                 |  3 +-
 4 files changed, 77 insertions(+), 5 deletions(-)

diff --git a/score/launch_manager/src/daemon/src/process_group_manager/details/graph.cpp b/score/launch_manager/src/daemon/src/process_group_manager/details/graph.cpp
index e62099bcd..fc32fe6e9 100644
--- a/score/launch_manager/src/daemon/src/process_group_manager/details/graph.cpp
+++ b/score/launch_manager/src/daemon/src/process_group_manager/details/graph.cpp
@@ -551,7 +551,15 @@ std::chrono::milliseconds Graph::getMaxTerminationTimeout()
     {
         if (const ProcessInfoNode* process = std::get_if<ProcessInfoNode>(&component))
         {
-            max_timeout = std::max(max_timeout, process->getTerminationTimeout());
+            // Only processes with a live OS process still to stop actually consume the
+            // SIGTERM+timeout wait during the transition to Off. Already terminated/failed
+            // processes short-circuit deactivation, and never-started nodes (pid == 0) have
+            // nothing to wait for, so neither should inflate the bound. This excludes
+            // one-shot / ready-on-termination processes that have already exited.
+            if (process->getPid() > 0 && process->getState() < ProcessState::kTerminated)
+            {
+                max_timeout = std::max(max_timeout, process->getTerminationTimeout());
+            }
         }
     }
     return max_timeout;
diff --git a/score/launch_manager/src/daemon/src/process_group_manager/details/graph.hpp b/score/launch_manager/src/daemon/src/process_group_manager/details/graph.hpp
index aa5872a0a..0038653c2 100644
--- a/score/launch_manager/src/daemon/src/process_group_manager/details/graph.hpp
+++ b/score/launch_manager/src/daemon/src/process_group_manager/details/graph.hpp
@@ -288,9 +288,11 @@ class Graph final
     /// @brief For forced shutdown, kill all leftover processes
     void forceKillProcesses();
 
-    /// @return The largest configured shutdown_timeout (termination_timeout_ms_) across the process
-    /// nodes of this process group, or zero if it has none. Used to bound the wait for the transition
-    /// to Off by the slowest process while still honouring each process's individual shutdown_timeout.
+    /// @brief Returns the largest configured shutdown_timeout across the processes
+    /// @details The largest configured shutdown_timeout (termination_timeout_ms_) across the process
+    /// nodes of this process group that still have a live process to stop (pid > 0 and not yet
+    /// terminated), or zero if there are none.
+    /// @return The timeout in milliseconds, or zero if there are no live processes to stop.
     std::chrono::milliseconds getMaxTerminationTimeout();
 
   private:
diff --git a/score/launch_manager/src/daemon/src/process_group_manager/details/graph_UT.cpp b/score/launch_manager/src/daemon/src/process_group_manager/details/graph_UT.cpp
index 2f4181357..5391b4a73 100644
--- a/score/launch_manager/src/daemon/src/process_group_manager/details/graph_UT.cpp
+++ b/score/launch_manager/src/daemon/src/process_group_manager/details/graph_UT.cpp
@@ -607,4 +607,65 @@ TEST_F(GraphUtilitiesTest, gettersSetters)
     EXPECT_LE(graph_time, after_time);
 }
 
+class GraphMaxTerminationTimeoutTest : public GraphTest
+{
+  protected:
+    uint32_t SetConfig() override
+    {
+        auto procs = generateProcessComponents(3);
+        auto count = procs.size();
+        procs[0].deployment_config.shutdown_timeout_ms = 1500;
+        procs[0].component_properties.application_profile.is_self_terminating = true;
+        procs[1].deployment_config.shutdown_timeout_ms = 500;
+        procs[2].deployment_config.shutdown_timeout_ms = 5000;
+        auto rts = generateRunTargets(2);
+        rts[1].depends_on = {procs[0].name, procs[1].name};
+        rts[2].depends_on = {procs[2].name};
+        const auto config = ConfigBuilder{}
+                                .setComponents(std::move(procs))
+                                .setRunTargets(std::move(rts))
+                                .setInitialRunTarget("Startup")
+                                .setFallbackRunTarget(std::move(fallback))
+                                .build();
+        config_.initialize(config);
+
+        return count;
+    }
+};
+
+TEST_F(GraphMaxTerminationTimeoutTest, ignoresNodesWithoutLiveProcess)
+{
+    RecordProperty(
+        "Description",
+        "Test that getMaxTerminationTimeout returns the max shutdown_timeout over running processes and ignores "
+        "never-started (pid == 0) nodes");
+
+    // No process started yet, so there is nothing to wait on.
+    EXPECT_EQ(graph_.getMaxTerminationTimeout(), 0ms);
+
+    // Bring up RunTarget0 (proc0 + proc1); proc2, with the largest timeout, stays idle in RunTarget1.
+    completeTransition(state_name(run_target_name(0)));
+
+    // Max over the two live processes; proc2's 5000 ms is ignored because it never started.
+    EXPECT_EQ(graph_.getMaxTerminationTimeout(), 1500ms);
+}
+
+TEST_F(GraphMaxTerminationTimeoutTest, ignoresTerminatedProcesses)
+{
+    RecordProperty(
+        "Description",
+        "Test that getMaxTerminationTimeout ignores processes that have already terminated, even if they carry the "
+        "largest shutdown_timeout");
+
+    completeTransition(state_name(run_target_name(0)));
+    ASSERT_EQ(graph_.getMaxTerminationTimeout(), 1500ms);
+
+    // proc0 is a self-terminating one-shot with the largest timeout; it exits on its own
+    // (status 0) and stays kTerminated, so it no longer needs to be waited on at shutdown.
+    static_cast<void>(graph_.getProcessInfoNode(0)->tryHandleTermination(0));
+
+    // Only proc1 remains live, so its timeout bounds the wait.
+    EXPECT_EQ(graph_.getMaxTerminationTimeout(), 500ms);
+}
+
 }  // namespace score::mw::lifecycle::internal
diff --git a/score/launch_manager/src/daemon/src/process_group_manager/process_group_manager.cpp b/score/launch_manager/src/daemon/src/process_group_manager/process_group_manager.cpp
index 43f538b94..a566860e1 100644
--- a/score/launch_manager/src/daemon/src/process_group_manager/process_group_manager.cpp
+++ b/score/launch_manager/src/daemon/src/process_group_manager/process_group_manager.cpp
@@ -478,7 +478,8 @@ void ProcessGroupManager::allProcessGroupsOff()
     // respected. Processes deactivate in parallel, so the largest per-process
     // timeout (plus the SIGKILL grace) bounds how long the transition can take.
     // Scope this to the process nodes of the graph being shut down (its own
-    // process group) rather than the whole configuration.
+    // process group) that still have a live process to stop, rather than the whole
+    // configuration - already terminated or never-started processes are not waited on.
     const auto off_transition_timeout = graph.getMaxTerminationTimeout() + kMaxSigKillDelay;
     if (!waitForStateCompletion(GraphState::kInTransition, static_cast<int32_t>(off_transition_timeout.count())))
     {

From 2a031a235f9f5e6a5f96e2a124f74f9dae480052 Mon Sep 17 00:00:00 2001
From: Timo Steuerwald <stt1rlz@bosch.com>
Date: Thu, 13 Aug 2026 14:45:15 +0200
Subject: [PATCH 11/23] Format fix

---
 tests/utils/bazel/integration.bzl  | 1 +
 tests/utils/plugins/integration.py | 4 +++-
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/tests/utils/bazel/integration.bzl b/tests/utils/bazel/integration.bzl
index d0d1ae7f1..e86f8d92b 100644
--- a/tests/utils/bazel/integration.bzl
+++ b/tests/utils/bazel/integration.bzl
@@ -101,6 +101,7 @@ def integration_test(
             "--local-dir=/tmp/score_itf_host/{}".format(name),
         ],
     })
+
     # integration_plugin is listed last so pytest registers it after the
     # target plugin: its docker_configuration fixture then overrides the
     # score_itf default (last-registered -p plugin wins fixture overrides).
diff --git a/tests/utils/plugins/integration.py b/tests/utils/plugins/integration.py
index 3fcf28da1..f7b370ee2 100644
--- a/tests/utils/plugins/integration.py
+++ b/tests/utils/plugins/integration.py
@@ -152,7 +152,9 @@ def _capture_core_dumps(request, target, test_output_dir):
     )
     enabled = rc == 0
     if not enabled:
-        logger.warning("Could not enable sandbox core dumps (core_pattern write failed)")
+        logger.warning(
+            "Could not enable sandbox core dumps (core_pattern write failed)"
+        )
 
     try:
         yield

From 8f7f8d667ec76a065841e18c9c736e868dc22528 Mon Sep 17 00:00:00 2001
From: Timo Steuerwald <stt1rlz@bosch.com>
Date: Thu, 13 Aug 2026 16:15:24 +0200
Subject: [PATCH 12/23] Reconstruct file paths automatically

---
 tests/utils/plugins/integration.py | 47 +++++++++++++++++++++++-------
 1 file changed, 37 insertions(+), 10 deletions(-)

diff --git a/tests/utils/plugins/integration.py b/tests/utils/plugins/integration.py
index f7b370ee2..b11f1d8d3 100644
--- a/tests/utils/plugins/integration.py
+++ b/tests/utils/plugins/integration.py
@@ -10,6 +10,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 # *******************************************************************************
+import json
 import logging
 import os
 import re
@@ -74,12 +75,36 @@ def docker_configuration():
     }
 
 
-# Crashing exe name (core_pattern %e, i.e. the process comm truncated to 15
-# chars) -> path of the built binary under the Bazel output tree, used to
-# suggest a ready-to-run gdb command. Extend this map as needed.
-_GDB_BINARIES = {
-    "launch_manager": "bin/score/launch_manager/src/daemon/launch_manager",
-}
+# Length the kernel truncates a process comm (core_pattern %e) to: TASK_COMM_LEN
+# is 16 bytes including the NUL terminator, so 15 usable characters.
+_COMM_MAX = 15
+
+
+def _load_binary_src_map(cores_dir: str):
+    """Map each packaged test binary's basename to its execroot-relative source
+    path (``bazel-out/<config>/bin/...``), read from the pkg_tar manifest that
+    ``integration_test`` builds next to ``environment.tar``.
+
+    This is Bazel's own dest->src mapping, so it resolves aliases and the right
+    per-config path automatically. Returns an empty dict on any failure; callers
+    then fall back to a ``<path-to-binary>`` placeholder."""
+    try:
+        tar = os.path.realpath(os.environ["SCORE_TEST_BINARY_PATH"])
+        manifest = Path(tar).with_suffix(".manifest")
+        if not manifest.is_file():
+            # Fall back to reconstructing the manifest path under bazel-out.
+            m = re.search(r"^(.*)/bazel-out/([^/]+)/", cores_dir)
+            rel = Path(os.environ["SCORE_TEST_BINARY_PATH"]).with_suffix(".manifest")
+            manifest = Path(f"{m.group(1)}/bazel-out/{m.group(2)}/bin") / rel
+        entries = json.loads(manifest.read_text())
+        return {
+            os.path.basename(e["dest"]): e["src"]
+            for e in entries
+            if e.get("type") == "file"
+        }
+    except Exception:
+        logger.warning("Could not load binary manifest for gdb hints", exc_info=True)
+        return {}
 
 
 def _persistent_outputs_dir(undeclared: str) -> str:
@@ -92,9 +117,9 @@ def _persistent_outputs_dir(undeclared: str) -> str:
 def _core_dump_report_lines(names, cores_dir: str):
     """Build the crash-dump banner body: the cores location plus a ready-to-run
     gdb command per core dump."""
-    m = re.search(r"^(.*)/bazel-out/([^/]+)/", cores_dir)
+    m = re.search(r"^(.*)/bazel-out/", cores_dir)
     out_root = m.group(1) if m else ""
-    config = m.group(2) if m else "k8-fastbuild"
+    src_map = _load_binary_src_map(cores_dir)
 
     lines = [
         f"CRASH DUMP HAS BEEN CREATED! See {cores_dir} for details.",
@@ -103,8 +128,10 @@ def _core_dump_report_lines(names, cores_dir: str):
     ]
     for name in names:
         exe = name.split(".")[1] if name.count(".") >= 1 else name
-        rel = _GDB_BINARIES.get(exe)
-        binary = f"{out_root}/bazel-out/{config}/{rel}" if rel else "<path-to-binary>"
+        # %e is the comm truncated to _COMM_MAX chars, so match on that prefix;
+        # bail out to a placeholder unless exactly one binary matches.
+        matches = [src for base, src in src_map.items() if base[:_COMM_MAX] == exe]
+        binary = f"{out_root}/{matches[0]}" if len(matches) == 1 else "<path-to-binary>"
         lines.append(f'    gdb {binary} "{cores_dir}/{name}"')
     return lines
 

From f6fc17465bdf9d05838b0a8274993f57dab0d888 Mon Sep 17 00:00:00 2001
From: Timo Steuerwald <stt1rlz@bosch.com>
Date: Thu, 13 Aug 2026 16:58:29 +0200
Subject: [PATCH 13/23] Align to naming schema on main branch

---
 tests/integration/lm_shutdown_during_rt_switch/BUILD            | 2 +-
 .../lm_shutdown_during_rt_switch.py                             | 2 +-
 .../{control_client_mock.cpp => mock_control_client.cpp}        | 0
 tests/integration/lm_shutdown_during_switch_to_off/BUILD        | 2 +-
 .../lm_shutdown_during_switch_to_off.py                         | 2 +-
 .../{control_client_mock.cpp => mock_control_client.cpp}        | 0
 6 files changed, 4 insertions(+), 4 deletions(-)
 rename tests/integration/lm_shutdown_during_rt_switch/{control_client_mock.cpp => mock_control_client.cpp} (100%)
 rename tests/integration/lm_shutdown_during_switch_to_off/{control_client_mock.cpp => mock_control_client.cpp} (100%)

diff --git a/tests/integration/lm_shutdown_during_rt_switch/BUILD b/tests/integration/lm_shutdown_during_rt_switch/BUILD
index 29ded4c31..71a161e68 100644
--- a/tests/integration/lm_shutdown_during_rt_switch/BUILD
+++ b/tests/integration/lm_shutdown_during_rt_switch/BUILD
@@ -21,7 +21,7 @@ cc_library(
 
 cc_binary(
     name = "control_client_mock",
-    srcs = ["control_client_mock.cpp"],
+    srcs = ["mock_control_client.cpp"],
     deps = [
         ":lm_shutdown_common",
         "//score/launch_manager:control_cc",
diff --git a/tests/integration/lm_shutdown_during_rt_switch/lm_shutdown_during_rt_switch.py b/tests/integration/lm_shutdown_during_rt_switch/lm_shutdown_during_rt_switch.py
index 8a0824e15..9ddf63c93 100644
--- a/tests/integration/lm_shutdown_during_rt_switch/lm_shutdown_during_rt_switch.py
+++ b/tests/integration/lm_shutdown_during_rt_switch/lm_shutdown_during_rt_switch.py
@@ -157,4 +157,4 @@ def test_lm_shutdown(
             proc.stop()
 
     # component_c never runs, so it produces no XML result.
-    assert_test_results({"control_client_mock.xml", "component_a.xml"})
+    assert_test_results({"mock_control_client.xml", "component_a.xml"})
diff --git a/tests/integration/lm_shutdown_during_rt_switch/control_client_mock.cpp b/tests/integration/lm_shutdown_during_rt_switch/mock_control_client.cpp
similarity index 100%
rename from tests/integration/lm_shutdown_during_rt_switch/control_client_mock.cpp
rename to tests/integration/lm_shutdown_during_rt_switch/mock_control_client.cpp
diff --git a/tests/integration/lm_shutdown_during_switch_to_off/BUILD b/tests/integration/lm_shutdown_during_switch_to_off/BUILD
index 3dd1da6f1..9abf6be26 100644
--- a/tests/integration/lm_shutdown_during_switch_to_off/BUILD
+++ b/tests/integration/lm_shutdown_during_switch_to_off/BUILD
@@ -21,7 +21,7 @@ cc_library(
 
 cc_binary(
     name = "control_client_mock",
-    srcs = ["control_client_mock.cpp"],
+    srcs = ["mock_control_client.cpp"],
     deps = [
         ":lm_shutdown_common",
         "//score/launch_manager:control_cc",
diff --git a/tests/integration/lm_shutdown_during_switch_to_off/lm_shutdown_during_switch_to_off.py b/tests/integration/lm_shutdown_during_switch_to_off/lm_shutdown_during_switch_to_off.py
index a68c72c73..78059e530 100644
--- a/tests/integration/lm_shutdown_during_switch_to_off/lm_shutdown_during_switch_to_off.py
+++ b/tests/integration/lm_shutdown_during_switch_to_off/lm_shutdown_during_switch_to_off.py
@@ -186,4 +186,4 @@ def test_lm_shutdown(
     # produce their XML results: control_client is terminated when the switch to
     # Off begins, and component_a exits within its shutdown_timeout (which the
     # launch manager honours) instead of being force-terminated.
-    assert_test_results({"control_client_mock.xml", "component_a.xml"})
+    assert_test_results({"mock_control_client.xml", "component_a.xml"})
diff --git a/tests/integration/lm_shutdown_during_switch_to_off/control_client_mock.cpp b/tests/integration/lm_shutdown_during_switch_to_off/mock_control_client.cpp
similarity index 100%
rename from tests/integration/lm_shutdown_during_switch_to_off/control_client_mock.cpp
rename to tests/integration/lm_shutdown_during_switch_to_off/mock_control_client.cpp

From bb808b134ae3c1505c2814fd44a0306fae9819e1 Mon Sep 17 00:00:00 2001
From: Timo Steuerwald <stt1rlz@bosch.com>
Date: Fri, 14 Aug 2026 10:16:47 +0200
Subject: [PATCH 14/23] Update requirement name

---
 .../lm_shutdown_during_rt_switch.py                             | 2 +-
 .../lm_shutdown_during_switch_to_off.py                         | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/integration/lm_shutdown_during_rt_switch/lm_shutdown_during_rt_switch.py b/tests/integration/lm_shutdown_during_rt_switch/lm_shutdown_during_rt_switch.py
index 9ddf63c93..b413dffbe 100644
--- a/tests/integration/lm_shutdown_during_rt_switch/lm_shutdown_during_rt_switch.py
+++ b/tests/integration/lm_shutdown_during_rt_switch/lm_shutdown_during_rt_switch.py
@@ -68,7 +68,7 @@ def _launch_manager_pid(target):
 @add_test_properties(
     fully_verifies=[],
     partially_verifies=[
-        "comp_req__lifecycle__launcher_exit_shutdown",
+        "comp_req__launch_man__launcher_exit_shutdown",
     ],
     test_type="requirements-based",
     derivation_technique="requirements-analysis",
diff --git a/tests/integration/lm_shutdown_during_switch_to_off/lm_shutdown_during_switch_to_off.py b/tests/integration/lm_shutdown_during_switch_to_off/lm_shutdown_during_switch_to_off.py
index 78059e530..d135f6dc1 100644
--- a/tests/integration/lm_shutdown_during_switch_to_off/lm_shutdown_during_switch_to_off.py
+++ b/tests/integration/lm_shutdown_during_switch_to_off/lm_shutdown_during_switch_to_off.py
@@ -68,7 +68,7 @@ def _launch_manager_pid(target):
 @add_test_properties(
     fully_verifies=[],
     partially_verifies=[
-        "comp_req__lifecycle__launcher_exit_shutdown",
+        "comp_req__launch_man__launcher_exit_shutdown",
     ],
     test_type="requirements-based",
     derivation_technique="requirements-analysis",

From 7e17a17be231d5bfcdc03c0b21c4ef6b2d1f1a5a Mon Sep 17 00:00:00 2001
From: Timo Steuerwald <stt1rlz@bosch.com>
Date: Fri, 14 Aug 2026 17:07:46 +0200
Subject: [PATCH 15/23] Change log level

---
 .../daemon/src/process_group_manager/process_group_manager.cpp  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/score/launch_manager/src/daemon/src/process_group_manager/process_group_manager.cpp b/score/launch_manager/src/daemon/src/process_group_manager/process_group_manager.cpp
index a566860e1..2ccd855e7 100644
--- a/score/launch_manager/src/daemon/src/process_group_manager/process_group_manager.cpp
+++ b/score/launch_manager/src/daemon/src/process_group_manager/process_group_manager.cpp
@@ -360,7 +360,7 @@ bool ProcessGroupManager::run()
 
             watchdog_->serviceWatchdog();
         }
-        LM_LOG_WARN() << "ProcessGroupManager::run() - received SIGTERM, exiting";
+        LM_LOG_INFO() << "ProcessGroupManager::run() - received SIGTERM, exiting";
     }
 
     allProcessGroupsOff();

From b59b010fb058958eae86b274215e6a0338ab8da2 Mon Sep 17 00:00:00 2001
From: Timo Steuerwald <stt1rlz@bosch.com>
Date: Mon, 17 Aug 2026 08:56:56 +0200
Subject: [PATCH 16/23] Shrink comments & tiny adaptions

---
 .../process_group_manager/details/graph.cpp   |  6 +----
 .../process_group_manager/details/graph.hpp   |  5 +---
 .../details/process_info_node.hpp             |  3 +--
 .../component_a.cpp                           | 14 +++--------
 .../mock_control_client.cpp                   |  5 +---
 .../component_a.cpp                           | 19 ++++-----------
 .../mock_control_client.cpp                   |  4 +---
 tests/utils/test_helper/test_helper.hpp       | 23 +++++--------------
 8 files changed, 18 insertions(+), 61 deletions(-)

diff --git a/score/launch_manager/src/daemon/src/process_group_manager/details/graph.cpp b/score/launch_manager/src/daemon/src/process_group_manager/details/graph.cpp
index fc32fe6e9..abfa8920c 100644
--- a/score/launch_manager/src/daemon/src/process_group_manager/details/graph.cpp
+++ b/score/launch_manager/src/daemon/src/process_group_manager/details/graph.cpp
@@ -551,11 +551,7 @@ std::chrono::milliseconds Graph::getMaxTerminationTimeout()
     {
         if (const ProcessInfoNode* process = std::get_if<ProcessInfoNode>(&component))
         {
-            // Only processes with a live OS process still to stop actually consume the
-            // SIGTERM+timeout wait during the transition to Off. Already terminated/failed
-            // processes short-circuit deactivation, and never-started nodes (pid == 0) have
-            // nothing to wait for, so neither should inflate the bound. This excludes
-            // one-shot / ready-on-termination processes that have already exited.
+            // Only processes with a live OS process still to stop count
             if (process->getPid() > 0 && process->getState() < ProcessState::kTerminated)
             {
                 max_timeout = std::max(max_timeout, process->getTerminationTimeout());
diff --git a/score/launch_manager/src/daemon/src/process_group_manager/details/graph.hpp b/score/launch_manager/src/daemon/src/process_group_manager/details/graph.hpp
index 0038653c2..4849623d4 100644
--- a/score/launch_manager/src/daemon/src/process_group_manager/details/graph.hpp
+++ b/score/launch_manager/src/daemon/src/process_group_manager/details/graph.hpp
@@ -288,10 +288,7 @@ class Graph final
     /// @brief For forced shutdown, kill all leftover processes
     void forceKillProcesses();
 
-    /// @brief Returns the largest configured shutdown_timeout across the processes
-    /// @details The largest configured shutdown_timeout (termination_timeout_ms_) across the process
-    /// nodes of this process group that still have a live process to stop (pid > 0 and not yet
-    /// terminated), or zero if there are none.
+    /// @brief Returns the largest configured shutdown_timeout across all running processes
     /// @return The timeout in milliseconds, or zero if there are no live processes to stop.
     std::chrono::milliseconds getMaxTerminationTimeout();
 
diff --git a/score/launch_manager/src/daemon/src/process_group_manager/details/process_info_node.hpp b/score/launch_manager/src/daemon/src/process_group_manager/details/process_info_node.hpp
index dff43b4ac..237b4e0b1 100644
--- a/score/launch_manager/src/daemon/src/process_group_manager/details/process_info_node.hpp
+++ b/score/launch_manager/src/daemon/src/process_group_manager/details/process_info_node.hpp
@@ -100,8 +100,7 @@ class ProcessInfoNode final : public IComponent
     /// @return The current state of this process.
     score::mw::lifecycle::ProcessState getState() const;
 
-    /// @return The configured shutdown_timeout (termination_timeout_ms_) for this process, or zero
-    /// if the node has no configuration.
+    /// @return The configured shutdown_timeout for this process, or zero
     std::chrono::milliseconds getTerminationTimeout() const;
 
     /// @return The ControlClientChannel for this process, or nullptr if none exists.
diff --git a/tests/integration/lm_shutdown_during_rt_switch/component_a.cpp b/tests/integration/lm_shutdown_during_rt_switch/component_a.cpp
index 3040c70ba..f77cc0bb9 100644
--- a/tests/integration/lm_shutdown_during_rt_switch/component_a.cpp
+++ b/tests/integration/lm_shutdown_during_rt_switch/component_a.cpp
@@ -19,17 +19,9 @@
 
 namespace
 {
-/// @brief How long component_a stalls while it is being terminated. During a
-/// run-target switch the launch manager runs the STOP phase (terminating
-/// no-longer-needed processes) fully before the START phase (activating newly
-/// needed processes). By stalling here, component_a keeps the switch in the STOP
-/// phase, giving the test a deterministic window to send SIGTERM to the launch
-/// manager before run_target_c could ever be activated.
-///
-/// It must be larger than the time the test needs to observe `a_terminating` and
-/// deliver the SIGTERM, and smaller than component_a's configured
-/// shutdown_timeout so the process still exits gracefully (and writes its XML
-/// result) rather than being SIGKILLed.
+/// @brief How long component_a stalls while being terminated, keeping the run-target
+/// switch in progress so the test can send SIGTERM to the launch manager in time. Must
+/// be smaller than component_a's configured shutdown_timeout so it still exits gracefully.
 constexpr unsigned int kTerminationDelaySeconds = 2U;
 }  // namespace
 
diff --git a/tests/integration/lm_shutdown_during_rt_switch/mock_control_client.cpp b/tests/integration/lm_shutdown_during_rt_switch/mock_control_client.cpp
index e3c2b8207..dcb24b9b9 100644
--- a/tests/integration/lm_shutdown_during_rt_switch/mock_control_client.cpp
+++ b/tests/integration/lm_shutdown_during_rt_switch/mock_control_client.cpp
@@ -58,10 +58,7 @@ TEST(LmShutdownDuringRtSwitch, ControlClient)
     }
 
     // Block until the launch manager terminates us as part of its own shutdown.
-    while (!TestRunner::exitRequested)
-    {
-        pause();
-    }
+    TestRunner::waitForTermination();
 
     TEST_STEP("Verify run_target_c was never activated")
     {
diff --git a/tests/integration/lm_shutdown_during_switch_to_off/component_a.cpp b/tests/integration/lm_shutdown_during_switch_to_off/component_a.cpp
index 4fe0fce87..771106673 100644
--- a/tests/integration/lm_shutdown_during_switch_to_off/component_a.cpp
+++ b/tests/integration/lm_shutdown_during_switch_to_off/component_a.cpp
@@ -19,26 +19,15 @@
 
 namespace
 {
-/// @brief How long component_a stalls while it is being terminated. By stalling here, component_a keeps the switch (to
-/// the "Off" run target) in the STOP phase, giving the test a deterministic window to send SIGTERM to the launch
-/// manager while the switch to Off is still in progress.
-///
-/// It must be comfortably larger than the time the test needs to observe
-/// `a_terminating` and deliver the SIGTERM to the launch manager, so the switch
-/// to Off is still in progress when that SIGTERM arrives. It must also be
-/// comfortably smaller than component_a's configured shutdown_timeout: the launch
-/// manager honours that per-process shutdown_timeout during its own shutdown, so
-/// component_a is given time to exit on its own and terminates gracefully (and
-/// writes its XML result) rather than being force-terminated (SIGKILLed).
+/// @brief How long component_a stalls while being terminated, keeping the switch to Off
+/// in progress so the test can send SIGTERM to the launch manager in time. Must be smaller
+/// than component_a's configured shutdown_timeout so it still exits gracefully.
 constexpr unsigned int kTerminationDelaySeconds = 2U;
 }  // namespace
 
 TEST(LmShutdownDuringSwitchToOff, ComponentA)
 {
-    const auto pid = getpid();
-    const std::string step_msg = "Report running with pid == " + std::to_string(pid);
-
-    TEST_STEP(step_msg)
+    TEST_STEP("Report running")
     {
         EXPECT_TRUE(touch_file(a_started)) << "failed to deploy file";
         score::mw::lifecycle::report_running();
diff --git a/tests/integration/lm_shutdown_during_switch_to_off/mock_control_client.cpp b/tests/integration/lm_shutdown_during_switch_to_off/mock_control_client.cpp
index f14acf842..61c29b549 100644
--- a/tests/integration/lm_shutdown_during_switch_to_off/mock_control_client.cpp
+++ b/tests/integration/lm_shutdown_during_switch_to_off/mock_control_client.cpp
@@ -63,9 +63,7 @@ TEST(LmShutdownDuringSwitchToOff, ControlClient)
         client.ActivateRunTarget("Off");
     }
 
-    // Block until the launch manager terminates us as part of the switch to Off /
-    // its own shutdown. See waitForTermination(): the ControlClient's background
-    // thread means we must not wait with a bare pause().
+    // Block until the launch manager terminates us as part of its own shutdown.
     TestRunner::waitForTermination();
 }
 
diff --git a/tests/utils/test_helper/test_helper.hpp b/tests/utils/test_helper/test_helper.hpp
index ca29dd7f2..56b2d505f 100644
--- a/tests/utils/test_helper/test_helper.hpp
+++ b/tests/utils/test_helper/test_helper.hpp
@@ -169,23 +169,12 @@ class TestRunner
     /// @brief True if the test process has received SIGINT or SIGTERM
     inline static std::atomic<bool> exitRequested = false;
 
-    /// @brief Block the calling (main) thread until the test process is asked to
-    /// terminate (a SIGINT/SIGTERM sets exitRequested via signalHandler).
-    ///
-    /// Poll the atomic flag instead of calling pause() directly. A process-directed
-    /// signal (from kill) is delivered to an arbitrary one of the process's threads
-    /// that has the signal unblocked. If the test process has more than one thread
-    /// (e.g. a ControlClient, whose constructor spawns a background IPC thread), the
-    /// handler may run on a background thread and set exitRequested there. pause()
-    /// only returns for a signal handled on the calling thread, so a main thread
-    /// blocked in pause() would not wake - it would stay parked until the launch
-    /// manager SIGKILLs it at its shutdown_timeout, and never write its XML result.
-    /// Polling observes the flag regardless of which thread handled the signal.
-    ///
-    /// TODO: A GitHub issue shall be created to adopt this helper in the remaining
-    /// tests/integration/*/control_client_mock.cpp binaries, which still wait with a
-    /// bare pause() and are subject to the same race. Kept out of the current PR to
-    /// keep its scope contained.
+    /// @brief Block the calling thread until a SIGINT/SIGTERM sets exitRequested.
+    /// @details Polls the flag instead of pause(): a process-directed signal may be
+    /// handled on a background thread (e.g. the ControlClient's IPC thread), which a
+    /// main thread parked in pause() would never observe.
+    // TODO: adopt this in the remaining tests/integration/*/*control*.cpp binaries
+    // that still wait with a bare pause().
     static void waitForTermination()
     {
         while (!exitRequested)

From a4fff219168b21b9cd24cf3196036d60be16a5af Mon Sep 17 00:00:00 2001
From: Timo Steuerwald <stt1rlz@bosch.com>
Date: Mon, 17 Aug 2026 12:58:57 +0200
Subject: [PATCH 17/23] Refactor code to simply use run_until_file_deployed(..)

---
 .../lm_shutdown_during_rt_switch.py           | 134 ++-----------
 .../lm_shutdown_during_switch_to_off.py       | 178 +++---------------
 2 files changed, 48 insertions(+), 264 deletions(-)

diff --git a/tests/integration/lm_shutdown_during_rt_switch/lm_shutdown_during_rt_switch.py b/tests/integration/lm_shutdown_during_rt_switch/lm_shutdown_during_rt_switch.py
index b413dffbe..ea3b97ecb 100644
--- a/tests/integration/lm_shutdown_during_rt_switch/lm_shutdown_during_rt_switch.py
+++ b/tests/integration/lm_shutdown_during_rt_switch/lm_shutdown_during_rt_switch.py
@@ -10,60 +10,11 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 # *******************************************************************************
-import logging
-import time
-
+from tests.utils.testing_utils.run_until_file_deployed import run_until_file_deployed
 from tests.utils.testing_utils.setup_test import setup_test
 from tests.utils.testing_utils.test_results import assert_test_results
 from attribute_plugin import add_test_properties
 
-logger = logging.getLogger(__name__)
-
-
-def _wait_for_file(target, file_path, proc, timeout_s):
-    """Block until `file_path` exists on the target, or raise on timeout / early
-    exit of the launch manager process."""
-    deadline = time.monotonic() + timeout_s
-    while time.monotonic() < deadline:
-        if not proc.is_running():
-            raise RuntimeError(
-                f"Launch manager exited (code {proc.get_exit_code()}) before "
-                f"'{file_path}' appeared. Output:\n{proc.get_output()}"
-            )
-        exit_code, _ = target.execute(f"test -f {file_path}")
-        if exit_code == 0:
-            return
-        time.sleep(0.05)
-    raise TimeoutError(f"'{file_path}' did not appear within {timeout_s}s")
-
-
-def _pids_by_comm(target, name):
-    """Return the PIDs whose process name matches `name`.
-
-    The test sandbox provides neither ``pgrep`` nor ``ps``, so processes are
-    located by scanning ``/proc/<pid>/comm`` using only shell builtins and
-    ``cat``. Linux truncates the process name (``comm``) to 15 characters, so
-    the target name is truncated the same way before comparing.
-    """
-    truncated = name[:15]
-    scan = (
-        "for p in /proc/[0-9]*/comm; do "
-        'c=$(cat "$p" 2>/dev/null) || continue; '
-        f'if [ "$c" = "{truncated}" ]; then '
-        "q=${p#/proc/}; echo ${q%/comm}; fi; "
-        "done"
-    )
-    exit_code, stdout = target.execute(scan)
-    if exit_code != 0:
-        return []
-    return [int(pid) for pid in stdout.decode().split()]
-
-
-def _launch_manager_pid(target):
-    """Return the PID of the running launch_manager process, or None."""
-    pids = _pids_by_comm(target, "launch_manager")
-    return pids[0] if pids else None
-
 
 @add_test_properties(
     fully_verifies=[],
@@ -73,9 +24,7 @@ def _launch_manager_pid(target):
     test_type="requirements-based",
     derivation_technique="requirements-analysis",
 )
-def test_lm_shutdown(
-    target, setup_test, assert_test_results, remote_test_dir, test_output_dir
-):
+def test_lm_shutdown(target, setup_test, assert_test_results, remote_test_dir):
     """
     Objective: Verifies that the Launch Manager exits after performing a shutdown
     (stopping all processes it owns) when requested via SIGTERM, and that this
@@ -84,9 +33,9 @@ def test_lm_shutdown(
 
     The control client activates run_target_a and then requests a switch to
     run_target_c. component_a (only part of run_target_a) stalls while it is being
-    terminated during the switch, keeping the switch in progress. At that point
-    the test sends a SIGTERM to the launch manager process (only that process, not
-    the whole group, so the launch manager performs its own orderly shutdown).
+    terminated during the switch, keeping the switch in progress. That window is
+    signalled by the file `component_a_terminating`, at which point the launch
+    manager is sent a SIGTERM.
 
     Expected Behaviour: The launch manager cancels the pending switch - so
     component_c (only part of run_target_c) is never started - stops all the
@@ -94,67 +43,24 @@ def test_lm_shutdown(
     """
 
     new_config_path = str(remote_test_dir / "etc/lm_shutdown_during_rt_switch.bin")
-
     a_terminating = remote_test_dir / "component_a_terminating"
-    c_started = remote_test_dir / "component_c_started"
 
-    proc = target.execute_async(
-        str(remote_test_dir / "launch_manager"),
-        args=["-c", new_config_path],
+    # Run the launch manager until component_a signals it is stalling mid-termination
+    # (file `component_a_terminating`): the switch to run_target_c is then in progress
+    # but run_target_c has not been activated yet. run_until_file_deployed stops the
+    # launch manager at that point by sending it a SIGTERM (to the launch manager
+    # process only, so it performs its own orderly shutdown) and asserts it exits
+    # cleanly (code 0).
+    run_until_file_deployed(
+        target=target,
+        binary_path=str(remote_test_dir / "launch_manager"),
+        file_path=a_terminating,
         cwd=str(remote_test_dir),
+        args=["-c", new_config_path],
+        timeout_s=10.0,
     )
 
-    try:
-        # Wait until the switch to run_target_c is underway: component_a is being
-        # terminated (and is now stalling), so run_target_c has not been activated
-        # yet. This state is signalled via file a_terminating.
-        # This is the window in which the shutdown request must win.
-        _wait_for_file(target, a_terminating, proc, timeout_s=10.0)
-
-        # run_target_c must not have started yet at this point.
-        exit_code, _ = target.execute(f"test -f {c_started}")
-        # The assertion below could only fail if either the sleep in component_a's termination code is too short
-        # or component_a has been killed by launch manager, because it takes too long to react on SIGTERM.
-        assert exit_code != 0, (
-            "run_target_c was activated before shutdown was requested - this should not happen"
-        )
-
-        # Request shutdown: send SIGTERM to the launch manager process only, so
-        # that the launch manager itself stops the processes it owns (rather than
-        # the OS terminating the whole process group directly).
-        lm_pid = _launch_manager_pid(target)
-        assert lm_pid is not None, "Could not find the running launch_manager process"
-        logger.info(f"Sending SIGTERM to launch_manager (pid {lm_pid})")
-        exit_code, _ = target.execute(f"kill -15 {lm_pid}")
-        assert exit_code == 0, "Failed to send SIGTERM to the launch manager"
-
-        # The launch manager must exit after completing its shutdown.
-        deadline = time.monotonic() + 10.0
-        while proc.is_running() and time.monotonic() < deadline:
-            time.sleep(0.1)
-        assert not proc.is_running(), (
-            f"Launch manager did not exit after SIGTERM. Output:\n{proc.get_output()}"
-        )
-        assert proc.get_exit_code() == 0, (
-            f"Launch manager did not exit cleanly (code {proc.get_exit_code()}). "
-            f"Output:\n{proc.get_output()}"
-        )
-
-        # The pending switch must have been cancelled: run_target_c never activated.
-        exit_code, _ = target.execute(f"test -f {c_started}")
-        assert exit_code != 0, (
-            "run_target_c was activated: the SIGTERM shutdown request must cancel the pending switch"
-        )
-
-        # The launch manager must have stopped all the processes it owns.
-        for binary in ("component_a", "component_c", "control_client_mock"):
-            running = _pids_by_comm(target, binary)
-            assert not running, (
-                f"'{binary}' is still running (pids {running}) after launch manager shutdown"
-            )
-    finally:
-        if proc.is_running():
-            proc.stop()
-
-    # component_c never runs, so it produces no XML result.
+    # component_c never runs (the pending switch was cancelled), so it produces no XML
+    # result; component_a and the control client shut down gracefully. The control
+    # client additionally asserts that run_target_c was never activated.
     assert_test_results({"mock_control_client.xml", "component_a.xml"})
diff --git a/tests/integration/lm_shutdown_during_switch_to_off/lm_shutdown_during_switch_to_off.py b/tests/integration/lm_shutdown_during_switch_to_off/lm_shutdown_during_switch_to_off.py
index d135f6dc1..dba9d7acd 100644
--- a/tests/integration/lm_shutdown_during_switch_to_off/lm_shutdown_during_switch_to_off.py
+++ b/tests/integration/lm_shutdown_during_switch_to_off/lm_shutdown_during_switch_to_off.py
@@ -10,60 +10,11 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 # *******************************************************************************
-import logging
-import time
-
+from tests.utils.testing_utils.run_until_file_deployed import run_until_file_deployed
 from tests.utils.testing_utils.setup_test import setup_test
 from tests.utils.testing_utils.test_results import assert_test_results
 from attribute_plugin import add_test_properties
 
-logger = logging.getLogger(__name__)
-
-
-def _wait_for_file(target, file_path, proc, timeout_s):
-    """Block until `file_path` exists on the target, or raise on timeout / early
-    exit of the launch manager process."""
-    deadline = time.monotonic() + timeout_s
-    while time.monotonic() < deadline:
-        if not proc.is_running():
-            raise RuntimeError(
-                f"Launch manager exited (code {proc.get_exit_code()}) before "
-                f"'{file_path}' appeared. Output:\n{proc.get_output()}"
-            )
-        exit_code, _ = target.execute(f"test -f {file_path}")
-        if exit_code == 0:
-            return
-        time.sleep(0.05)
-    raise TimeoutError(f"'{file_path}' did not appear within {timeout_s}s")
-
-
-def _pids_by_comm(target, name):
-    """Return the PIDs whose process name matches `name`.
-
-    The test sandbox provides neither ``pgrep`` nor ``ps``, so processes are
-    located by scanning ``/proc/<pid>/comm`` using only shell builtins and
-    ``cat``. Linux truncates the process name (``comm``) to 15 characters, so
-    the target name is truncated the same way before comparing.
-    """
-    truncated = name[:15]
-    scan = (
-        "for p in /proc/[0-9]*/comm; do "
-        'c=$(cat "$p" 2>/dev/null) || continue; '
-        f'if [ "$c" = "{truncated}" ]; then '
-        "q=${p#/proc/}; echo ${q%/comm}; fi; "
-        "done"
-    )
-    exit_code, stdout = target.execute(scan)
-    if exit_code != 0:
-        return []
-    return [int(pid) for pid in stdout.decode().split()]
-
-
-def _launch_manager_pid(target):
-    """Return the PID of the running launch_manager process, or None."""
-    pids = _pids_by_comm(target, "launch_manager")
-    return pids[0] if pids else None
-
 
 @add_test_properties(
     fully_verifies=[],
@@ -73,117 +24,44 @@ def _launch_manager_pid(target):
     test_type="requirements-based",
     derivation_technique="requirements-analysis",
 )
-def test_lm_shutdown(
-    target, setup_test, assert_test_results, remote_test_dir, test_output_dir
-):
+def test_lm_shutdown(target, setup_test, assert_test_results, remote_test_dir):
     """
     Objective: Verifies that the Launch Manager exits after performing a shutdown
-    (stopping all processes it owns) when requested via SIGTERM, and that a
-    SIGTERM that arrives while an explicit switch to the "Off" run target is
-    already in progress lets that switch to Off continue to completion (it must
-    NOT be cancelled and redone).
+    (stopping all processes it owns) when a SIGTERM arrives while an explicit switch
+    to the "Off" run target is already in progress.
 
-    The control client activates run_target_a and then explicitly requests a
-    switch to the "Off" run target. component_a (part of run_target_a) stalls
-    while it is being terminated during that switch, keeping the switch to Off in
-    progress. At that point the test sends a SIGTERM to the launch manager process
-    (only that process, not the whole group, so the launch manager performs its
-    own orderly shutdown).
+    The control client activates run_target_a and then explicitly requests a switch
+    to the "Off" run target. component_a (part of run_target_a) stalls while it is
+    being terminated during that switch, keeping the switch to Off in progress. That
+    window is signalled by the file `component_a_terminating`, at which point the
+    launch manager is sent a SIGTERM.
 
     Expected Behaviour: The launch manager lets the in-progress switch to Off
-    continue - it must NOT cancel the explicit switch to Off and redo it - all the
-    processes it owns are stopped, and it exits cleanly.
-
-    The launch manager honours each component's individual shutdown_timeout during
-    its own shutdown: it waits for the in-progress transition to Off to complete,
-    giving every process up to its configured shutdown_timeout to exit before it
-    would be force-terminated. component_a stalls for less than its shutdown_timeout
-    while it is being terminated, so it is given time to exit on its own and
-    terminates gracefully (producing its XML result) rather than being SIGKILLed.
+    continue, stops all the processes it owns, and exits cleanly. It honours each
+    component's shutdown_timeout, so component_a - which stalls for less than its
+    shutdown_timeout - exits gracefully (producing its XML result) rather than being
+    force-terminated.
     """
 
     new_config_path = str(remote_test_dir / "etc/lm_shutdown_during_switch_to_off.bin")
-
     a_terminating = remote_test_dir / "component_a_terminating"
 
-    proc = target.execute_async(
-        str(remote_test_dir / "launch_manager"),
-        args=["-c", new_config_path],
+    # Run the launch manager until component_a signals it is stalling mid-termination
+    # (file `component_a_terminating`): the explicit switch to Off is then in progress.
+    # run_until_file_deployed stops the launch manager at that point by sending it a
+    # SIGTERM (to the launch manager process only, so it performs its own orderly
+    # shutdown) and asserts it exits cleanly (code 0).
+    run_until_file_deployed(
+        target=target,
+        binary_path=str(remote_test_dir / "launch_manager"),
+        file_path=a_terminating,
         cwd=str(remote_test_dir),
+        args=["-c", new_config_path],
+        timeout_s=10.0,
     )
 
-    try:
-        # Wait until the switch to Off is underway: component_a is being terminated
-        # (and is now stalling). This is signalled via file a_terminating and is
-        # the window in which the shutdown request arrives.
-        _wait_for_file(target, a_terminating, proc, timeout_s=10.0)
-
-        # Request shutdown: send SIGTERM to the launch manager process only, so
-        # that the launch manager itself stops the processes it owns (rather than
-        # the OS terminating the whole process group directly).
-        lm_pid = _launch_manager_pid(target)
-        assert lm_pid is not None, "Could not find the running launch_manager process"
-        logger.info(f"Sending SIGTERM to launch_manager (pid {lm_pid})")
-        exit_code, _ = target.execute(f"kill -15 {lm_pid}")
-        assert exit_code == 0, "Failed to send SIGTERM to the launch manager"
-
-        # The launch manager must exit after completing its shutdown.
-        deadline = time.monotonic() + 10.0
-        while proc.is_running() and time.monotonic() < deadline:
-            time.sleep(0.1)
-        assert not proc.is_running(), (
-            f"Launch manager did not exit after SIGTERM. Output:\n{proc.get_output()}"
-        )
-        assert proc.get_exit_code() == 0, (
-            f"Launch manager did not exit cleanly (code {proc.get_exit_code()}). "
-            f"Output:\n{proc.get_output()}"
-        )
-
-        # The launch manager must have stopped all the processes it owns.
-        for binary in ("component_a", "control_client_mock"):
-            running = _pids_by_comm(target, binary)
-            assert not running, (
-                f"'{binary}' is still running (pids {running}) after launch manager shutdown"
-            )
-
-        # Core assertion: the explicit switch to Off must be CONTINUED, not
-        # cancelled and redone.
-        #
-        # The switch to Off was already in progress (MainPG in transition to Off)
-        # when the SIGTERM arrived, so the SIGTERM-triggered shutdown must simply
-        # let it finish. If instead the launch manager cancels that transition, the
-        # main process group logs a "kInTransition -> kCancelled" transition after
-        # the SIGTERM was received. That must not happen. (The only legitimate
-        # cancellation - the Startup -> run_target_a switch - happens before the
-        # SIGTERM, so scoping the check to after the SIGTERM marker excludes it.)
-        output = proc.get_output()
-        if isinstance(output, bytes):
-            output = output.decode(errors="replace")
-
-        sigterm_marker = "received SIGTERM"
-        marker_index = output.find(sigterm_marker)
-        assert marker_index != -1, (
-            f"Launch manager never logged receiving the SIGTERM.\nOutput:\n{output}"
-        )
-        output_after_sigterm = output[marker_index:]
-
-        cancelled_lines = [
-            line
-            for line in output_after_sigterm.splitlines()
-            if "to kCancelled" in line and "MainPG" in line
-        ]
-        assert not cancelled_lines, (
-            "The explicit switch to Off was cancelled and redone by the launch "
-            "manager during shutdown instead of being continued. Offending log "
-            "line(s):\n" + "\n".join(cancelled_lines) + "\n\n"
-            f"Full launch manager output after SIGTERM:\n{output_after_sigterm}"
-        )
-    finally:
-        if proc.is_running():
-            proc.stop()
-
-    # Both components are stopped gracefully as part of the switch to Off and
-    # produce their XML results: control_client is terminated when the switch to
-    # Off begins, and component_a exits within its shutdown_timeout (which the
-    # launch manager honours) instead of being force-terminated.
+    # Both processes are stopped gracefully as part of the switch to Off and produce
+    # their XML results: the control client is terminated when the switch to Off
+    # begins, and component_a exits within its shutdown_timeout (which the launch
+    # manager honours) instead of being force-terminated.
     assert_test_results({"mock_control_client.xml", "component_a.xml"})

From e363ada0ddc081db3fc627dc7c6daac81729eafe Mon Sep 17 00:00:00 2001
From: Timo Steuerwald <stt1rlz@bosch.com>
Date: Mon, 17 Aug 2026 14:45:51 +0200
Subject: [PATCH 18/23] Get rid of identical component_a.cpp files.

---
 .../lm_shutdown_during_rt_switch/BUILD        | 28 +++----
 .../component_a.cpp                           | 53 --------------
 .../lm_shutdown_during_rt_switch.json         |  2 +-
 .../lm_shutdown_during_switch_to_off/BUILD    | 13 +---
 .../component_a.cpp                           | 53 --------------
 .../lm_shutdown_during_switch_to_off.json     |  2 +-
 tests/utils/test_helper/BUILD                 | 11 +++
 .../process_hanging_on_sigterm.cpp            | 73 +++++++++++++++++++
 8 files changed, 98 insertions(+), 137 deletions(-)
 delete mode 100644 tests/integration/lm_shutdown_during_rt_switch/component_a.cpp
 delete mode 100644 tests/integration/lm_shutdown_during_switch_to_off/component_a.cpp
 create mode 100644 tests/utils/test_helper/process_hanging_on_sigterm.cpp

diff --git a/tests/integration/lm_shutdown_during_rt_switch/BUILD b/tests/integration/lm_shutdown_during_rt_switch/BUILD
index 71a161e68..ba7559001 100644
--- a/tests/integration/lm_shutdown_during_rt_switch/BUILD
+++ b/tests/integration/lm_shutdown_during_rt_switch/BUILD
@@ -31,29 +31,23 @@ cc_binary(
     ],
 )
 
-[
-    cc_binary(
-        name = component,
-        srcs = [component + ".cpp"],
-        deps = [
-            ":lm_shutdown_common",
-            "//score/launch_manager:lifecycle_cc",
-            "//tests/utils/test_helper",
-            "@googletest//:gtest_main",
-        ],
-    )
-    for component in [
-        "component_a",
-        "component_c",
-    ]
-]
+cc_binary(
+    name = "component_c",
+    srcs = ["component_c.cpp"],
+    deps = [
+        ":lm_shutdown_common",
+        "//score/launch_manager:lifecycle_cc",
+        "//tests/utils/test_helper",
+        "@googletest//:gtest_main",
+    ],
+)
 
 integration_test(
     name = "lm_shutdown_during_rt_switch",
     timeout = "short",
     srcs = ["lm_shutdown_during_rt_switch.py"],
     binaries = [
-        ":component_a",
+        "//tests/utils/test_helper:process_hanging_on_sigterm",
         ":component_c",
         ":control_client_mock",
         "//score/launch_manager",
diff --git a/tests/integration/lm_shutdown_during_rt_switch/component_a.cpp b/tests/integration/lm_shutdown_during_rt_switch/component_a.cpp
deleted file mode 100644
index f77cc0bb9..000000000
--- a/tests/integration/lm_shutdown_during_rt_switch/component_a.cpp
+++ /dev/null
@@ -1,53 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2026 Contributors to the Eclipse Foundation
- *
- * See the NOTICE file(s) distributed with this work for additional
- * information regarding copyright ownership.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Apache License Version 2.0 which is available at
- * https://www.apache.org/licenses/LICENSE-2.0
- *
- * SPDX-License-Identifier: Apache-2.0
- ********************************************************************************/
-#include <gtest/gtest.h>
-#include <unistd.h>
-
-#include "common.hpp"
-#include "tests/utils/test_helper/test_helper.hpp"
-#include <score/mw/lifecycle/report_running.h>
-
-namespace
-{
-/// @brief How long component_a stalls while being terminated, keeping the run-target
-/// switch in progress so the test can send SIGTERM to the launch manager in time. Must
-/// be smaller than component_a's configured shutdown_timeout so it still exits gracefully.
-constexpr unsigned int kTerminationDelaySeconds = 2U;
-}  // namespace
-
-TEST(LmShutdownDuringRtSwitch, ComponentA)
-{
-    TEST_STEP("Report running")
-    {
-        EXPECT_TRUE(touch_file(a_started)) << "failed to deploy file";
-        score::mw::lifecycle::report_running();
-    }
-
-    // Wait until the launch manager asks us to terminate (SIGTERM), which happens
-    // when the switch away from run_target_a begins.
-    while (!TestRunner::exitRequested)
-    {
-        pause();
-    }
-
-    TEST_STEP("Stall during termination to keep the run-target switch in progress")
-    {
-        EXPECT_TRUE(touch_file(a_terminating)) << "failed to deploy file";
-        static_cast<void>(sleep(kTerminationDelaySeconds));
-    }
-}
-
-int main()
-{
-    return TestRunner(__FILE__).RunTests();
-}
diff --git a/tests/integration/lm_shutdown_during_rt_switch/lm_shutdown_during_rt_switch.json b/tests/integration/lm_shutdown_during_rt_switch/lm_shutdown_during_rt_switch.json
index d1d538b17..8da0f3d10 100644
--- a/tests/integration/lm_shutdown_during_rt_switch/lm_shutdown_during_rt_switch.json
+++ b/tests/integration/lm_shutdown_during_rt_switch/lm_shutdown_during_rt_switch.json
@@ -62,7 +62,7 @@
         },
         "component_a": {
             "component_properties": {
-                "binary_name": "component_a"
+                "binary_name": "process_hanging_on_sigterm"
             },
             "deployment_config": {
                 "shutdown_timeout": 5.0,
diff --git a/tests/integration/lm_shutdown_during_switch_to_off/BUILD b/tests/integration/lm_shutdown_during_switch_to_off/BUILD
index 9abf6be26..7f05f607f 100644
--- a/tests/integration/lm_shutdown_during_switch_to_off/BUILD
+++ b/tests/integration/lm_shutdown_during_switch_to_off/BUILD
@@ -31,23 +31,12 @@ cc_binary(
     ],
 )
 
-cc_binary(
-    name = "component_a",
-    srcs = ["component_a.cpp"],
-    deps = [
-        ":lm_shutdown_common",
-        "//score/launch_manager:lifecycle_cc",
-        "//tests/utils/test_helper",
-        "@googletest//:gtest_main",
-    ],
-)
-
 integration_test(
     name = "lm_shutdown_during_switch_to_off",
     timeout = "short",
     srcs = ["lm_shutdown_during_switch_to_off.py"],
     binaries = [
-        ":component_a",
+        "//tests/utils/test_helper:process_hanging_on_sigterm",
         ":control_client_mock",
         "//score/launch_manager",
     ],
diff --git a/tests/integration/lm_shutdown_during_switch_to_off/component_a.cpp b/tests/integration/lm_shutdown_during_switch_to_off/component_a.cpp
deleted file mode 100644
index 771106673..000000000
--- a/tests/integration/lm_shutdown_during_switch_to_off/component_a.cpp
+++ /dev/null
@@ -1,53 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2026 Contributors to the Eclipse Foundation
- *
- * See the NOTICE file(s) distributed with this work for additional
- * information regarding copyright ownership.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Apache License Version 2.0 which is available at
- * https://www.apache.org/licenses/LICENSE-2.0
- *
- * SPDX-License-Identifier: Apache-2.0
- ********************************************************************************/
-#include <gtest/gtest.h>
-#include <unistd.h>
-
-#include "common.hpp"
-#include "tests/utils/test_helper/test_helper.hpp"
-#include <score/mw/lifecycle/report_running.h>
-
-namespace
-{
-/// @brief How long component_a stalls while being terminated, keeping the switch to Off
-/// in progress so the test can send SIGTERM to the launch manager in time. Must be smaller
-/// than component_a's configured shutdown_timeout so it still exits gracefully.
-constexpr unsigned int kTerminationDelaySeconds = 2U;
-}  // namespace
-
-TEST(LmShutdownDuringSwitchToOff, ComponentA)
-{
-    TEST_STEP("Report running")
-    {
-        EXPECT_TRUE(touch_file(a_started)) << "failed to deploy file";
-        score::mw::lifecycle::report_running();
-    }
-
-    // Wait until the launch manager asks us to terminate (SIGTERM), which happens
-    // when the switch away from run_target_a (to the "Off" run target) begins.
-    while (!TestRunner::exitRequested)
-    {
-        pause();
-    }
-
-    TEST_STEP("Stall during termination to keep the run-target switch in progress")
-    {
-        EXPECT_TRUE(touch_file(a_terminating)) << "failed to deploy file";
-        static_cast<void>(sleep(kTerminationDelaySeconds));
-    }
-}
-
-int main()
-{
-    return TestRunner(__FILE__).RunTests();
-}
diff --git a/tests/integration/lm_shutdown_during_switch_to_off/lm_shutdown_during_switch_to_off.json b/tests/integration/lm_shutdown_during_switch_to_off/lm_shutdown_during_switch_to_off.json
index 2c460da3d..81bf5ab26 100644
--- a/tests/integration/lm_shutdown_during_switch_to_off/lm_shutdown_during_switch_to_off.json
+++ b/tests/integration/lm_shutdown_during_switch_to_off/lm_shutdown_during_switch_to_off.json
@@ -62,7 +62,7 @@
         },
         "component_a": {
             "component_properties": {
-                "binary_name": "component_a"
+                "binary_name": "process_hanging_on_sigterm"
             },
             "deployment_config": {
                 "shutdown_timeout": 5.0,
diff --git a/tests/utils/test_helper/BUILD b/tests/utils/test_helper/BUILD
index c044cce2c..900780ca1 100644
--- a/tests/utils/test_helper/BUILD
+++ b/tests/utils/test_helper/BUILD
@@ -64,6 +64,17 @@ cc_binary(
     ],
 )
 
+cc_binary(
+    name = "process_hanging_on_sigterm",
+    srcs = ["process_hanging_on_sigterm.cpp"],
+    visibility = ["//tests:__subpackages__"],
+    deps = [
+        ":test_helper",
+        "//score/launch_manager:lifecycle_cc",
+        "@googletest//:gtest_main",
+    ],
+)
+
 cc_binary(
     name = "process_crashing_on_startup_n_times",
     srcs = ["process_crashing_on_startup_n_times.cpp"],
diff --git a/tests/utils/test_helper/process_hanging_on_sigterm.cpp b/tests/utils/test_helper/process_hanging_on_sigterm.cpp
new file mode 100644
index 000000000..86a61d064
--- /dev/null
+++ b/tests/utils/test_helper/process_hanging_on_sigterm.cpp
@@ -0,0 +1,73 @@
+/********************************************************************************
+ * Copyright (c) 2026 Contributors to the Eclipse Foundation
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information regarding copyright ownership.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Apache License Version 2.0 which is available at
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ ********************************************************************************/
+#include <gtest/gtest.h>
+#include <unistd.h>
+
+#include <cstdlib>
+#include <string>
+#include <string_view>
+
+#include "tests/utils/test_helper/test_helper.hpp"
+#include <score/mw/lifecycle/report_running.h>
+
+namespace
+{
+/// @brief How long the process stalls while being terminated, keeping an in-progress
+/// run-target switch alive so the test has a deterministic window to send SIGTERM to
+/// the launch manager. Must be smaller than the configured shutdown_timeout so the
+/// process still exits gracefully.
+constexpr unsigned int kTerminationDelaySeconds = 2U;
+
+/// @return "<PROCESSIDENTIFIER>_<suffix>", or just <suffix> if PROCESSIDENTIFIER is
+/// unset. Keeps signal files distinct when this shared binary is deployed as several
+/// components.
+std::string signal_file(const std::string_view suffix)
+{
+    const char* process_id = std::getenv("PROCESSIDENTIFIER");
+    return process_id ? (std::string{process_id} + "_" + std::string{suffix}) : std::string{suffix};
+}
+}  // namespace
+
+// Reports running, then - once the launch manager asks it to terminate (SIGTERM),
+// which happens when the switch away from its run target begins - stalls for a short
+// while before exiting. The stall keeps that run-target switch in progress, giving the
+// surrounding test a deterministic window to act (e.g. send a SIGTERM to the launch
+// manager).
+TEST(ProcessHangingOnSigterm, StallsDuringTermination)
+{
+    TEST_STEP("Report running")
+    {
+        EXPECT_TRUE(touch_file(signal_file("started"))) << "failed to deploy file";
+        score::mw::lifecycle::report_running();
+    }
+
+    while (!TestRunner::exitRequested)
+    {
+        pause();
+    }
+
+    TEST_STEP("Stall during termination to keep the run-target switch in progress")
+    {
+        EXPECT_TRUE(touch_file(signal_file("terminating"))) << "failed to deploy file";
+        static_cast<void>(sleep(kTerminationDelaySeconds));
+    }
+}
+
+int main()
+{
+    // Name the XML result after the deployed component so multiple deployments of this
+    // shared binary don't collide.
+    const char* process_id = std::getenv("PROCESSIDENTIFIER");
+    const std::string xml_name = process_id ? std::string{process_id} : __FILE__;
+    return TestRunner(xml_name).RunTests();
+}

From 4b8f851a546d4696a6dd1c274d1fcc072a710340 Mon Sep 17 00:00:00 2001
From: Timo Steuerwald <stt1rlz@bosch.com>
Date: Mon, 17 Aug 2026 15:45:31 +0200
Subject: [PATCH 19/23] Update comment regarding deinit order

---
 .../process_group_manager/process_group_manager.cpp | 13 +++----------
 1 file changed, 3 insertions(+), 10 deletions(-)

diff --git a/score/launch_manager/src/daemon/src/process_group_manager/process_group_manager.cpp b/score/launch_manager/src/daemon/src/process_group_manager/process_group_manager.cpp
index 2ccd855e7..6caaabb92 100644
--- a/score/launch_manager/src/daemon/src/process_group_manager/process_group_manager.cpp
+++ b/score/launch_manager/src/daemon/src/process_group_manager/process_group_manager.cpp
@@ -470,16 +470,9 @@ void ProcessGroupManager::allProcessGroupsOff()
 
     LM_LOG_DEBUG() << "Wait for all process groups to complete the transition";
 
-    // Each worker deactivating a process already honours that process's configured
-    // shutdown_timeout: it sends SIGTERM, waits up to termination_timeout_ms_ for a
-    // graceful exit and only then SIGKILLs (waiting a further kMaxSigKillDelay).
-    // Bound the wait for the whole transition to Off by the slowest such process
-    // rather than a fixed grace period, so every component's shutdown_timeout is
-    // respected. Processes deactivate in parallel, so the largest per-process
-    // timeout (plus the SIGKILL grace) bounds how long the transition can take.
-    // Scope this to the process nodes of the graph being shut down (its own
-    // process group) that still have a live process to stop, rather than the whole
-    // configuration - already terminated or never-started processes are not waited on.
+    // Bound the whole transition-to-Off wait by the slowest still-running process's
+    // shutdown_timeout (plus the SIGKILL grace), so every component's configured
+    // timeout is honoured. Processes deactivate in parallel.
     const auto off_transition_timeout = graph.getMaxTerminationTimeout() + kMaxSigKillDelay;
     if (!waitForStateCompletion(GraphState::kInTransition, static_cast<int32_t>(off_transition_timeout.count())))
     {

From e5e7c74f94a7655312a704841ba5fc23d99c5f72 Mon Sep 17 00:00:00 2001
From: Timo Steuerwald <stt1rlz@bosch.com>
Date: Mon, 17 Aug 2026 18:29:03 +0200
Subject: [PATCH 20/23] Move control client mocks -> test driver

---
 .../{mock_control_client.cpp => control_client_test_driver.cpp}   | 0
 .../{mock_control_client.cpp => control_client_test_driver.cpp}   | 0
 2 files changed, 0 insertions(+), 0 deletions(-)
 rename tests/integration/lm_shutdown_during_rt_switch/{mock_control_client.cpp => control_client_test_driver.cpp} (100%)
 rename tests/integration/lm_shutdown_during_switch_to_off/{mock_control_client.cpp => control_client_test_driver.cpp} (100%)

diff --git a/tests/integration/lm_shutdown_during_rt_switch/mock_control_client.cpp b/tests/integration/lm_shutdown_during_rt_switch/control_client_test_driver.cpp
similarity index 100%
rename from tests/integration/lm_shutdown_during_rt_switch/mock_control_client.cpp
rename to tests/integration/lm_shutdown_during_rt_switch/control_client_test_driver.cpp
diff --git a/tests/integration/lm_shutdown_during_switch_to_off/mock_control_client.cpp b/tests/integration/lm_shutdown_during_switch_to_off/control_client_test_driver.cpp
similarity index 100%
rename from tests/integration/lm_shutdown_during_switch_to_off/mock_control_client.cpp
rename to tests/integration/lm_shutdown_during_switch_to_off/control_client_test_driver.cpp

From 4958a85926cd4943755f23258b92aefba35eb4f8 Mon Sep 17 00:00:00 2001
From: Timo Steuerwald <stt1rlz@bosch.com>
Date: Mon, 17 Aug 2026 18:36:00 +0200
Subject: [PATCH 21/23] Update references to control_client_test_driver

---
 tests/integration/lm_shutdown_during_rt_switch/BUILD        | 6 +++---
 .../lm_shutdown_during_rt_switch.json                       | 4 ++--
 .../lm_shutdown_during_rt_switch.py                         | 2 +-
 tests/integration/lm_shutdown_during_switch_to_off/BUILD    | 6 +++---
 .../lm_shutdown_during_switch_to_off.json                   | 4 ++--
 .../lm_shutdown_during_switch_to_off.py                     | 2 +-
 6 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/tests/integration/lm_shutdown_during_rt_switch/BUILD b/tests/integration/lm_shutdown_during_rt_switch/BUILD
index ba7559001..d5b2c0d52 100644
--- a/tests/integration/lm_shutdown_during_rt_switch/BUILD
+++ b/tests/integration/lm_shutdown_during_rt_switch/BUILD
@@ -20,8 +20,8 @@ cc_library(
 )
 
 cc_binary(
-    name = "control_client_mock",
-    srcs = ["mock_control_client.cpp"],
+    name = "control_client_test_driver",
+    srcs = ["control_client_test_driver.cpp"],
     deps = [
         ":lm_shutdown_common",
         "//score/launch_manager:control_cc",
@@ -49,7 +49,7 @@ integration_test(
     binaries = [
         "//tests/utils/test_helper:process_hanging_on_sigterm",
         ":component_c",
-        ":control_client_mock",
+        ":control_client_test_driver",
         "//score/launch_manager",
     ],
     config = ":lm_shutdown_during_rt_switch.json",
diff --git a/tests/integration/lm_shutdown_during_rt_switch/lm_shutdown_during_rt_switch.json b/tests/integration/lm_shutdown_during_rt_switch/lm_shutdown_during_rt_switch.json
index 8da0f3d10..9376cba98 100644
--- a/tests/integration/lm_shutdown_during_rt_switch/lm_shutdown_during_rt_switch.json
+++ b/tests/integration/lm_shutdown_during_rt_switch/lm_shutdown_during_rt_switch.json
@@ -44,7 +44,7 @@
     "components": {
         "component_initial": {
             "component_properties": {
-                "binary_name": "control_client_mock",
+                "binary_name": "control_client_test_driver",
                 "application_profile": {
                     "application_type": "State_Manager",
                     "alive_supervision": {
@@ -56,7 +56,7 @@
                 "ready_timeout": 1.0,
                 "shutdown_timeout": 1.0,
                 "environmental_variables": {
-                    "PROCESSIDENTIFIER": "control_client_mock"
+                    "PROCESSIDENTIFIER": "control_client_test_driver"
                 }
             }
         },
diff --git a/tests/integration/lm_shutdown_during_rt_switch/lm_shutdown_during_rt_switch.py b/tests/integration/lm_shutdown_during_rt_switch/lm_shutdown_during_rt_switch.py
index ea3b97ecb..611597b68 100644
--- a/tests/integration/lm_shutdown_during_rt_switch/lm_shutdown_during_rt_switch.py
+++ b/tests/integration/lm_shutdown_during_rt_switch/lm_shutdown_during_rt_switch.py
@@ -63,4 +63,4 @@ def test_lm_shutdown(target, setup_test, assert_test_results, remote_test_dir):
     # component_c never runs (the pending switch was cancelled), so it produces no XML
     # result; component_a and the control client shut down gracefully. The control
     # client additionally asserts that run_target_c was never activated.
-    assert_test_results({"mock_control_client.xml", "component_a.xml"})
+    assert_test_results({"control_client_test_driver.xml", "component_a.xml"})
diff --git a/tests/integration/lm_shutdown_during_switch_to_off/BUILD b/tests/integration/lm_shutdown_during_switch_to_off/BUILD
index 7f05f607f..88512b86c 100644
--- a/tests/integration/lm_shutdown_during_switch_to_off/BUILD
+++ b/tests/integration/lm_shutdown_during_switch_to_off/BUILD
@@ -20,8 +20,8 @@ cc_library(
 )
 
 cc_binary(
-    name = "control_client_mock",
-    srcs = ["mock_control_client.cpp"],
+    name = "control_client_test_driver",
+    srcs = ["control_client_test_driver.cpp"],
     deps = [
         ":lm_shutdown_common",
         "//score/launch_manager:control_cc",
@@ -37,7 +37,7 @@ integration_test(
     srcs = ["lm_shutdown_during_switch_to_off.py"],
     binaries = [
         "//tests/utils/test_helper:process_hanging_on_sigterm",
-        ":control_client_mock",
+        ":control_client_test_driver",
         "//score/launch_manager",
     ],
     config = ":lm_shutdown_during_switch_to_off.json",
diff --git a/tests/integration/lm_shutdown_during_switch_to_off/lm_shutdown_during_switch_to_off.json b/tests/integration/lm_shutdown_during_switch_to_off/lm_shutdown_during_switch_to_off.json
index 81bf5ab26..ac67c6af7 100644
--- a/tests/integration/lm_shutdown_during_switch_to_off/lm_shutdown_during_switch_to_off.json
+++ b/tests/integration/lm_shutdown_during_switch_to_off/lm_shutdown_during_switch_to_off.json
@@ -44,7 +44,7 @@
     "components": {
         "component_initial": {
             "component_properties": {
-                "binary_name": "control_client_mock",
+                "binary_name": "control_client_test_driver",
                 "application_profile": {
                     "application_type": "State_Manager",
                     "alive_supervision": {
@@ -56,7 +56,7 @@
                 "ready_timeout": 1.0,
                 "shutdown_timeout": 5.0,
                 "environmental_variables": {
-                    "PROCESSIDENTIFIER": "control_client_mock"
+                    "PROCESSIDENTIFIER": "control_client_test_driver"
                 }
             }
         },
diff --git a/tests/integration/lm_shutdown_during_switch_to_off/lm_shutdown_during_switch_to_off.py b/tests/integration/lm_shutdown_during_switch_to_off/lm_shutdown_during_switch_to_off.py
index dba9d7acd..428998649 100644
--- a/tests/integration/lm_shutdown_during_switch_to_off/lm_shutdown_during_switch_to_off.py
+++ b/tests/integration/lm_shutdown_during_switch_to_off/lm_shutdown_during_switch_to_off.py
@@ -64,4 +64,4 @@ def test_lm_shutdown(target, setup_test, assert_test_results, remote_test_dir):
     # their XML results: the control client is terminated when the switch to Off
     # begins, and component_a exits within its shutdown_timeout (which the launch
     # manager honours) instead of being force-terminated.
-    assert_test_results({"mock_control_client.xml", "component_a.xml"})
+    assert_test_results({"control_client_test_driver.xml", "component_a.xml"})

From bc1085de0fff3e8a488a62cf35fba5d262a30a2c Mon Sep 17 00:00:00 2001
From: Timo Steuerwald <stt1rlz@bosch.com>
Date: Tue, 18 Aug 2026 17:45:31 +0200
Subject: [PATCH 22/23] Get rid of waitForTermination()

In tests a colleague proved that SIGTERM always leads to a pause() call returning, as long as the pause() call is on the main thread. Which is the case here, so it is not needed.
---
 .../control_client_test_driver.cpp                 |  5 ++++-
 .../control_client_test_driver.cpp                 |  5 ++++-
 tests/utils/test_helper/test_helper.hpp            | 14 --------------
 3 files changed, 8 insertions(+), 16 deletions(-)

diff --git a/tests/integration/lm_shutdown_during_rt_switch/control_client_test_driver.cpp b/tests/integration/lm_shutdown_during_rt_switch/control_client_test_driver.cpp
index dcb24b9b9..e3c2b8207 100644
--- a/tests/integration/lm_shutdown_during_rt_switch/control_client_test_driver.cpp
+++ b/tests/integration/lm_shutdown_during_rt_switch/control_client_test_driver.cpp
@@ -58,7 +58,10 @@ TEST(LmShutdownDuringRtSwitch, ControlClient)
     }
 
     // Block until the launch manager terminates us as part of its own shutdown.
-    TestRunner::waitForTermination();
+    while (!TestRunner::exitRequested)
+    {
+        pause();
+    }
 
     TEST_STEP("Verify run_target_c was never activated")
     {
diff --git a/tests/integration/lm_shutdown_during_switch_to_off/control_client_test_driver.cpp b/tests/integration/lm_shutdown_during_switch_to_off/control_client_test_driver.cpp
index 61c29b549..9a8187e62 100644
--- a/tests/integration/lm_shutdown_during_switch_to_off/control_client_test_driver.cpp
+++ b/tests/integration/lm_shutdown_during_switch_to_off/control_client_test_driver.cpp
@@ -64,7 +64,10 @@ TEST(LmShutdownDuringSwitchToOff, ControlClient)
     }
 
     // Block until the launch manager terminates us as part of its own shutdown.
-    TestRunner::waitForTermination();
+    while (!TestRunner::exitRequested)
+    {
+        pause();
+    }
 }
 
 int main()
diff --git a/tests/utils/test_helper/test_helper.hpp b/tests/utils/test_helper/test_helper.hpp
index 56b2d505f..82c942946 100644
--- a/tests/utils/test_helper/test_helper.hpp
+++ b/tests/utils/test_helper/test_helper.hpp
@@ -169,20 +169,6 @@ class TestRunner
     /// @brief True if the test process has received SIGINT or SIGTERM
     inline static std::atomic<bool> exitRequested = false;
 
-    /// @brief Block the calling thread until a SIGINT/SIGTERM sets exitRequested.
-    /// @details Polls the flag instead of pause(): a process-directed signal may be
-    /// handled on a background thread (e.g. the ControlClient's IPC thread), which a
-    /// main thread parked in pause() would never observe.
-    // TODO: adopt this in the remaining tests/integration/*/*control*.cpp binaries
-    // that still wait with a bare pause().
-    static void waitForTermination()
-    {
-        while (!exitRequested)
-        {
-            std::this_thread::sleep_for(std::chrono::milliseconds(10));
-        }
-    }
-
     /// @brief Use this function in main() to run all tests. It returns 0 if all tests are successful, or 1 otherwise.
     int RunTests()
     {

From 26b29e59a307e8cdfbeb6c2f42b987218a55025d Mon Sep 17 00:00:00 2001
From: Timo Steuerwald <stt1rlz@bosch.com>
Date: Tue, 18 Aug 2026 17:47:06 +0200
Subject: [PATCH 23/23] Shrink comments

---
 .../lm_shutdown_during_rt_switch.py                       | 8 ++------
 .../lm_shutdown_during_switch_to_off.py                   | 7 ++-----
 2 files changed, 4 insertions(+), 11 deletions(-)

diff --git a/tests/integration/lm_shutdown_during_rt_switch/lm_shutdown_during_rt_switch.py b/tests/integration/lm_shutdown_during_rt_switch/lm_shutdown_during_rt_switch.py
index 611597b68..52cd0141d 100644
--- a/tests/integration/lm_shutdown_during_rt_switch/lm_shutdown_during_rt_switch.py
+++ b/tests/integration/lm_shutdown_during_rt_switch/lm_shutdown_during_rt_switch.py
@@ -45,12 +45,8 @@ def test_lm_shutdown(target, setup_test, assert_test_results, remote_test_dir):
     new_config_path = str(remote_test_dir / "etc/lm_shutdown_during_rt_switch.bin")
     a_terminating = remote_test_dir / "component_a_terminating"
 
-    # Run the launch manager until component_a signals it is stalling mid-termination
-    # (file `component_a_terminating`): the switch to run_target_c is then in progress
-    # but run_target_c has not been activated yet. run_until_file_deployed stops the
-    # launch manager at that point by sending it a SIGTERM (to the launch manager
-    # process only, so it performs its own orderly shutdown) and asserts it exits
-    # cleanly (code 0).
+    # Run until `component_a_terminating` is deployed so we can request shutdown during
+    # the transition to run target c
     run_until_file_deployed(
         target=target,
         binary_path=str(remote_test_dir / "launch_manager"),
diff --git a/tests/integration/lm_shutdown_during_switch_to_off/lm_shutdown_during_switch_to_off.py b/tests/integration/lm_shutdown_during_switch_to_off/lm_shutdown_during_switch_to_off.py
index 428998649..d7ae836d7 100644
--- a/tests/integration/lm_shutdown_during_switch_to_off/lm_shutdown_during_switch_to_off.py
+++ b/tests/integration/lm_shutdown_during_switch_to_off/lm_shutdown_during_switch_to_off.py
@@ -46,11 +46,8 @@ def test_lm_shutdown(target, setup_test, assert_test_results, remote_test_dir):
     new_config_path = str(remote_test_dir / "etc/lm_shutdown_during_switch_to_off.bin")
     a_terminating = remote_test_dir / "component_a_terminating"
 
-    # Run the launch manager until component_a signals it is stalling mid-termination
-    # (file `component_a_terminating`): the explicit switch to Off is then in progress.
-    # run_until_file_deployed stops the launch manager at that point by sending it a
-    # SIGTERM (to the launch manager process only, so it performs its own orderly
-    # shutdown) and asserts it exits cleanly (code 0).
+    # Run until `component_a_terminating` is deployed so we can send SIGTERM 
+    # to launch manager during the transition to Off
     run_until_file_deployed(
         target=target,
         binary_path=str(remote_test_dir / "launch_manager"),