added review comment fixes listed below :

- H6 — C++ DependencyOrdering/ParallelLaunching now build a real score::hm::HealthMonitorBuilder + DeadlineMonitorBuilder and throw on build() failure, matching Rust's real API usage (previously pure print/sleep stubs).
- L1/L2/L7 — deleted dead code in lifecycle_scenario.py (copy_test_app_to_daemon_workspace, create_launch_manager_config, read_launch_manager_config, create_daemon_integrated_config) that targeted a non-existent Bazel package and was never called.
- L3 — replaced unsound regex-based JSON array parsing in the C++ scenario file with proper score::json library parsing scoped to the test object.
- L4 — daemon now starts in its own process group (start_new_session=True) and stop() signals the whole group via os.killpg, preventing orphaned supervised children; log file now appends instead of truncating on restart.
- L5 — recovery test now matches on the exact deployed binary path instead of a fragile bare-name pgrep -f substring match.
- M1/M2/M4(remainder)/M5 — config values that coincided with scenario hardcoded defaults changed to distinctive values (e.g. watchdog_interval_ms 100→137), so a broken config-read path is now distinguishable from a default fallback.
- M3 — I/O redirection paths are now genuinely config-driven in both C++ and Rust (previously hardcoded literals).
- M6, M8, M9 — ConfigurationManagement, DebugAndTerminal, ControlInterfaceCommands scenario classes now branch on actual config values in both languages instead of printing fixed self-fulfilling output.
- M7 — log timestamp is now a real ISO-8601/epoch timestamp, checked via regex instead of a literal string.
- M10 — dependency-ordering test now verifies checkpoints are emitted in non-decreasing order, not just present.
- M11 — trimmed over-claimed partially_verifies requirement lists in 3 test files down to IDs with matching assertions.

Author: Saumya-R

feature_integration_tests/test_cases/daemon_helpers.py

@@ -276,18 +276,23 @@ def start(self, startup_timeout: float = 2.0) -> None:
         if self.process is not None:
             raise RuntimeError("Daemon already started")
 
-        # Create log file
+        # Create/append to log file so logs from a prior start() (e.g. before a
+        # restart) are preserved instead of being discarded.
         self.log_file = self.working_dir / "launch_manager.log"
-        self._log_fd = open(self.log_file, "w")
+        self._log_fd = open(self.log_file, "a")
 
-        # Start daemon process
+        # Start daemon process in its own process group so stop() can signal
+        # the whole supervision tree, not just the daemon itself. Otherwise
+        # supervised child processes are orphaned on daemon crash/restart and
+        # linger to pollute later pgrep-based assertions.
         cmd = [str(self.daemon_binary), str(self.config_file)]
         self.process = subprocess.Popen(
             cmd,
             cwd=self.working_dir,
             stdout=self._log_fd,
             stderr=subprocess.STDOUT,
             text=True,
+            start_new_session=True,
         )
 
         # Wait for daemon to initialize
@@ -315,18 +320,22 @@ def stop(self, shutdown_timeout: float = 5.0) -> None:
             return
 
         try:
-            # Send SIGTERM for graceful shutdown if still running.
+            # Send SIGTERM to the whole process group for graceful shutdown if
+            # still running, so supervised children are not orphaned.
             if self.process.poll() is None:
                 try:
-                    self.process.send_signal(signal.SIGTERM)
+                    os.killpg(self.process.pid, signal.SIGTERM)
                 except ProcessLookupError:
                     pass
 
             try:
                 self.process.wait(timeout=shutdown_timeout)
             except subprocess.TimeoutExpired:
-                # Force kill if graceful shutdown fails.
-                self.process.kill()
+                # Force kill the whole process group if graceful shutdown fails.
+                try:
+                    os.killpg(self.process.pid, signal.SIGKILL)
+                except ProcessLookupError:
+                    pass
                 self.process.wait()
         finally:
             self.process = None

feature_integration_tests/test_cases/lifecycle_scenario.py

@@ -17,175 +17,12 @@
 shared ``temp_dir`` fixture so individual test classes do not have to duplicate it.
 """
 
-import json
-import shutil
 from collections.abc import Generator
 from pathlib import Path
 from typing import Any
 
 import pytest
 from fit_scenario import FitScenario, temp_dir_common
-from testing_utils import BazelTools
-
-
-def read_launch_manager_config(config_path: Path) -> dict[str, Any]:
-    """
-    Read and parse the launch manager configuration JSON file.
-
-    Parameters
-    ----------
-    config_path : Path
-        Path to the launch manager configuration file.
-
-    Returns
-    -------
-    dict
-        Parsed launch manager configuration.
-    """
-    return json.loads(config_path.read_text())
-
-
-def create_launch_manager_config(config_path: Path, components: dict[str, Any], run_targets: dict[str, Any]) -> Path:
-    """
-    Create a launch manager configuration JSON file.
-
-    Parameters
-    ----------
-    config_path : Path
-        Path where the configuration file should be created.
-    components : dict
-        Component definitions for the launch manager.
-    run_targets : dict
-        Run target definitions.
-
-    Returns
-    -------
-    Path
-        Path to the created configuration file.
-    """
-    config = {
-        "schema_version": 1,
-        "defaults": {
-            "deployment_config": {
-                "bin_dir": "/tmp/lifecycle_test/bin/",
-                "ready_recovery_action": {"restart": {"number_of_attempts": 1, "delay_before_restart": 0.5}},
-                "sandbox": {
-                    "uid": 0,
-                    "gid": 0,
-                    "supplementary_group_ids": [],
-                    "scheduling_policy": "SCHED_OTHER",
-                    "scheduling_priority": 1,
-                },
-            },
-            "component_properties": {
-                "application_profile": {
-                    "application_type": "Reporting",
-                    "is_self_terminating": False,
-                },
-                "depends_on": [],
-                "process_arguments": [],
-                "ready_condition": {"process_state": "Running"},
-            },
-            "run_target": {
-                "transition_timeout": 5,
-                "recovery_action": {"switch_run_target": {"run_target": "fallback_run_target"}},
-            },
-        },
-        "components": components,
-        "run_targets": run_targets,
-        "initial_run_target": "startup",
-        "fallback_run_target": {
-            "description": "Fallback state",
-            "depends_on": [],
-            "transition_timeout": 1.5,
-        },
-    }
-    config_path.write_text(json.dumps(config, indent=2))
-    return config_path
-
-
-def create_daemon_integrated_config(
-    config_path: Path,
-    bin_dir: Path,
-    components: dict[str, Any],
-    run_targets: dict[str, Any] | None = None,
-    enable_health_monitoring: bool = True,
-) -> Path:
-    """
-    Create a Launch Manager configuration for daemon integration tests.
-
-    Parameters
-    ----------
-    config_path : Path
-        Path where the configuration file should be created.
-    bin_dir : Path
-        Directory containing application binaries.
-    components : dict
-        Component definitions with supervised applications.
-    run_targets : dict, optional
-        Run target definitions. If None, uses default startup/running/fallback.
-    enable_health_monitoring : bool
-        Whether to enable alive supervision for components.
-
-    Returns
-    -------
-    Path
-        Path to the created configuration file.
-    """
-    if run_targets is None:
-        run_targets = {
-            "startup": {"description": "System startup", "depends_on": []},
-            "running": {"description": "Normal operation", "depends_on": []},
-            "fallback": {"description": "Fallback mode", "depends_on": [], "transition_timeout": 5},
-        }
-
-    alive_supervision = {}
-    if enable_health_monitoring:
-        alive_supervision = {
-            "alive_supervision": {
-                "reporting_cycle": 0.1,
-                "min_indications": 1,
-                "max_indications": 3,
-                "failed_cycles_tolerance": 2,
-            }
-        }
-
-    config = {
-        "schema_version": 1,
-        "defaults": {
-            "deployment_config": {
-                "bin_dir": str(bin_dir) + "/",
-                "ready_recovery_action": {"restart": {"number_of_attempts": 3, "delay_before_restart": 0.5}},
-                "sandbox": {
-                    "uid": 0,
-                    "gid": 0,
-                    "supplementary_group_ids": [],
-                    "scheduling_policy": "SCHED_OTHER",
-                    "scheduling_priority": 1,
-                },
-            },
-            "component_properties": {
-                "application_profile": {
-                    "application_type": "Reporting",
-                    "is_self_terminating": False,
-                    **alive_supervision,
-                },
-                "depends_on": [],
-                "process_arguments": [],
-                "ready_condition": {"process_state": "Running"},
-            },
-            "run_target": {
-                "transition_timeout": 10,
-                "recovery_action": {"switch_run_target": {"run_target": "fallback"}},
-            },
-        },
-        "components": components,
-        "run_targets": run_targets,
-        "initial_run_target": "startup",
-        "fallback_run_target": {"description": "Fallback state", "depends_on": [], "transition_timeout": 1.5},
-    }
-    config_path.write_text(json.dumps(config, indent=2))
-    return config_path
 
 
 def add_supervised_component(
@@ -235,39 +72,6 @@ def add_supervised_component(
     return component
 
 
-def copy_test_app_to_daemon_workspace(daemon_info: dict[str, Any], app_name: str, version: str = "rust") -> Path:
-    """
-    Copy a test application binary to the daemon workspace.
-
-    Parameters
-    ----------
-    daemon_info : dict
-        Daemon information from launch_manager_daemon fixture.
-    app_name : str
-        Name of the test application (e.g., "supervised_test_app").
-    version : str
-        Implementation version: "rust" or "cpp".
-
-    Returns
-    -------
-    Path
-        Path to the copied binary in daemon workspace.
-    """
-    # Build the test application
-    tools = BazelTools(option_prefix=version)
-    target_suffix = "_rust" if version == "rust" else "_cpp"
-    target = f"//feature_integration_tests/test_apps:{app_name}{target_suffix}"
-    tools.build(target)
-    source_path = tools.find_target_path(target)
-
-    # Copy to daemon bin directory
-    dest_path = daemon_info["bin_dir"] / (app_name if version == "rust" else f"{app_name}_cpp")
-    shutil.copy2(source_path, dest_path)
-    dest_path.chmod(0o755)
-
-    return dest_path
-
-
 class LifecycleScenario(FitScenario):
     """
     Base class for lifecycle feature integration tests.

feature_integration_tests/test_cases/tests/lifecycle/test_conditional_launching.py

@@ -69,8 +69,8 @@ def test_config(self, temp_dir: Path) -> dict[str, Any]:
             "test": {
                 "test_duration_ms": 300,
                 "wait_conditions": ["path:/tmp/ready", "env:STARTUP_COMPLETE", "process:init_done"],
-                "polling_interval_ms": 50,
-                "timeout_ms": 5000,
+                "polling_interval_ms": 173,
+                "timeout_ms": 6421,
             }
         }
 
@@ -121,9 +121,9 @@ def test_polling_interval_configured(
         assert results.return_code == ResultCode.SUCCESS
 
         if version == "cpp":
-            assert "Polling interval: 50ms" in results.stdout, "Polling interval not configured"
+            assert "Polling interval: 173ms" in results.stdout, "Polling interval not configured"
         else:
-            polling_logs = logs_info_level.get_logs(field="message", pattern="Polling interval: 50ms")
+            polling_logs = logs_info_level.get_logs(field="message", pattern="Polling interval: 173ms")
             assert len(polling_logs) > 0, "Polling interval not configured"
 
     def test_condition_timeout_configured(
@@ -135,9 +135,9 @@ def test_condition_timeout_configured(
         assert results.return_code == ResultCode.SUCCESS
 
         if version == "cpp":
-            assert "Condition timeout: 5000ms" in results.stdout, "Condition timeout not configured"
+            assert "Condition timeout: 6421ms" in results.stdout, "Condition timeout not configured"
         else:
-            timeout_logs = logs_info_level.get_logs(field="message", pattern="Condition timeout: 5000ms")
+            timeout_logs = logs_info_level.get_logs(field="message", pattern="Condition timeout: 6421ms")
             assert len(timeout_logs) > 0, "Condition timeout not configured"
 
     def test_dependency_check(self, results: ScenarioResult, logs_info_level: LogContainer, version: str) -> None:

feature_integration_tests/test_cases/tests/lifecycle/test_configuration_management.py

@@ -72,10 +72,16 @@ def test_modular_config_support(self, results: ScenarioResult, logs_info_level:
         assert results.return_code == ResultCode.SUCCESS
 
         if version == "cpp":
-            assert "Modular configuration loaded" in results.stdout, "Modular configuration not supported"
+            for module in ["base", "extended", "runtime"]:
+                assert f"Configuration module loaded: {module}" in results.stdout, (
+                    f"Configuration module {module} not loaded"
+                )
         else:
-            config_logs = logs_info_level.get_logs(field="message", value="Modular configuration loaded")
-            assert len(config_logs) > 0, "Modular configuration not supported"
+            for module in ["base", "extended", "runtime"]:
+                config_logs = logs_info_level.get_logs(
+                    field="message", pattern=f"Configuration module loaded: {module}"
+                )
+                assert len(config_logs) > 0, f"Configuration module {module} not loaded"
 
     def test_oci_compatibility(self, results: ScenarioResult, logs_info_level: LogContainer, version: str) -> None:
         """

feature_integration_tests/test_cases/tests/lifecycle/test_control_commands.py

@@ -56,7 +56,7 @@ def test_config(self, temp_dir: Path) -> dict[str, Any]:
         return {
             "test": {
                 "test_duration_ms": 200,
-                "commands": ["start", "stop", "status", "activate_run_target"],
+                "commands": ["pause", "resume", "diagnostics", "activate_run_target"],
             }
         }
 
@@ -69,14 +69,23 @@ def test_control_commands_available(
         assert results.return_code == ResultCode.SUCCESS
 
         if version == "cpp":
-            assert "Control commands available: start, stop, activate_run_target" in results.stdout, (
+            assert "Control commands available: pause, resume, diagnostics, activate_run_target" in results.stdout, (
                 "Control commands not available"
             )
+            for command in ["pause", "resume", "diagnostics", "activate_run_target"]:
+                assert f"Executing configured command: {command}" in results.stdout, (
+                    f"Configured command {command} was not executed"
+                )
         else:
             commands_logs = logs_info_level.get_logs(
-                field="message", pattern="Control commands available: start, stop, activate_run_target"
+                field="message", pattern="Control commands available: pause, resume, diagnostics, activate_run_target"
             )
             assert len(commands_logs) > 0, "Control commands not available"
+            for command in ["pause", "resume", "diagnostics", "activate_run_target"]:
+                exec_logs = logs_info_level.get_logs(
+                    field="message", pattern=f"Executing configured command: {command}"
+                )
+                assert len(exec_logs) > 0, f"Configured command {command} was not executed"
 
     def test_query_commands_available(
         self, results: ScenarioResult, logs_info_level: LogContainer, version: str

feature_integration_tests/test_cases/tests/lifecycle/test_control_interface_support.py

@@ -53,7 +53,7 @@ def test_config(self, temp_dir: Path) -> dict[str, Any]:
         return {
             "test": {
                 "test_duration_ms": 200,
-                "condition_name": "app_ready",
+                "condition_name": "custom_startup_barrier",
             }
         }
 
@@ -66,9 +66,13 @@ def test_custom_condition_signaled(
         assert results.return_code == ResultCode.SUCCESS
 
         if version == "cpp":
-            assert "Signaling custom condition: app_ready" in results.stdout, "Custom condition was not signaled"
+            assert "Signaling custom condition: custom_startup_barrier" in results.stdout, (
+                "Custom condition was not signaled"
+            )
         else:
-            condition_logs = logs_info_level.get_logs(field="message", pattern="Signaling custom condition: app_ready")
+            condition_logs = logs_info_level.get_logs(
+                field="message", pattern="Signaling custom condition: custom_startup_barrier"
+            )
             assert len(condition_logs) > 0, "Custom condition was not signaled"
 
     def test_control_interface_integration(