ddeutil-workflow 0.0.72__py3-none-any.whl → 0.0.74__py3-none-any.whl

ddeutil/workflow/stages.py

@@ -12,7 +12,7 @@ you can track logs.
 I do not want to handle stage error on this stage execution. I think stage model
 have a lot of use-case, and it should does not worry about it error output.
 
-    So, I will create `handler_execute` for any exception class that raise from
+    So, I will create `execute` for any exception class that raise from
 the stage execution method.
 
     Handler     --> Ok      --> Result
@@ -32,7 +32,7 @@ the stage execution method.
                                     |-name: ...
                                     ╰-message: ...
 
-    On the context I/O that pass to a stage object at execute process. The
+    On the context I/O that pass to a stage object at execute step. The
 execute method receives a `params={"params": {...}}` value for passing template
 searching.
 
@@ -95,6 +95,7 @@ from .result import (
     WAIT,
     Result,
     Status,
+    catch,
     get_status_from_error,
     validate_statuses,
 )
@@ -105,6 +106,7 @@ from .reusables import (
     not_in_template,
     param2template,
 )
+from .traces import Trace, get_trace
 from .utils import (
     delay,
     dump_all,
@@ -119,13 +121,40 @@ DictOrModel = Union[DictData, BaseModel]
 
 
 class BaseStage(BaseModel, ABC):
-    """Base Stage Model that keep only necessary fields like `id`, `name` or
-    `condition` for the stage metadata. If you want to implement any custom
-    stage, you can inherit this class and implement `self.execute()` method
-    only.
-
-        This class is the abstraction class for any inherit stage model that
-    want to implement on this workflow package.
+    """Abstract base class for all stage implementations.
+
+    BaseStage provides the foundation for all stage types in the workflow system.
+    It defines the common interface and metadata fields that all stages must
+    implement, ensuring consistent behavior across different stage types.
+
+    This abstract class handles core stage functionality including:
+    - Stage identification and naming
+    - Conditional execution logic
+    - Output management and templating
+    - Execution lifecycle management
+
+    Custom stages should inherit from this class and implement the abstract
+    `process()` method to define their specific execution behavior.
+
+    Attributes:
+        extras (dict): Additional configuration parameters
+        id (str, optional): Unique stage identifier for output reference
+        name (str): Human-readable stage name for logging
+        desc (str, optional): Stage description for documentation
+        condition (str, optional): Conditional expression for execution
+
+    Abstract Methods:
+        process: Main execution logic that must be implemented by subclasses
+
+    Example:
+        ```python
+        class CustomStage(BaseStage):
+            custom_param: str = Field(description="Custom parameter")
+
+            def process(self, params: dict, **kwargs) -> Result:
+                # Custom execution logic
+                return Result(status=SUCCESS)
+        ```
     """
 
     extras: DictData = Field(
@@ -162,7 +191,8 @@ class BaseStage(BaseModel, ABC):
         """Return this stage identity that return the `id` field first and if
         this `id` field does not set, it will use the `name` field instead.
 
-        :rtype: str
+        Returns:
+            str: Return an identity of this stage for making output.
         """
         return self.id or self.name
 
@@ -194,37 +224,40 @@ class BaseStage(BaseModel, ABC):
         return self
 
     @abstractmethod
-    def execute(
+    def process(
         self,
         params: DictData,
+        run_id: str,
+        context: DictData,
         *,
-        result: Optional[Result] = None,
+        parent_run_id: Optional[str] = None,
         event: Optional[Event] = None,
     ) -> Result:
-        """Execute abstraction method that action something by sub-model class.
+        """Process abstraction method that action something by sub-model class.
         This is important method that make this class is able to be the stage.
 
-        :param params: (DictData) A parameter data that want to use in this
-            execution.
-        :param result: (Result) A result object for keeping context and status
-            data.
-        :param event: (Event) An event manager that use to track parent execute
-            was not force stopped.
-
-        :rtype: Result
+        Args:
+            params: A parameter data that want to use in this
+                execution.
+            run_id: A running stage ID.
+            context: A context data.
+            parent_run_id: A parent running ID. (Default is None)
+            event: An event manager that use to track parent process
+                was not force stopped.
+
+        Returns:
+            Result: The execution result with status and context data.
         """
-        raise NotImplementedError("Stage should implement `execute` method.")
+        raise NotImplementedError("Stage should implement `process` method.")
 
-    def handler_execute(
+    def execute(
         self,
         params: DictData,
         *,
         run_id: StrOrNone = None,
-        parent_run_id: StrOrNone = None,
-        result: Optional[Result] = None,
         event: Optional[Event] = None,
     ) -> Union[Result, DictData]:
-        """Handler stage execution result from the stage `execute` method.
+        """Handler stage execution result from the stage `process` method.
 
             This handler strategy will catch and mapping message to the result
         context data before returning. All possible status that will return from
@@ -250,33 +283,36 @@ class BaseStage(BaseModel, ABC):
             On the last step, it will set the running ID on a return result
         object from the current stage ID before release the final result.
 
-        :param params: (DictData) A parameter data.
-        :param run_id: (str) A running stage ID. (Default is None)
-        :param parent_run_id: (str) A parent running ID. (Default is None)
-        :param result: (Result) A result object for keeping context and status
-            data before execution.
-            (Default is None)
-        :param event: (Event) An event manager that pass to the stage execution.
-            (Default is None)
+        Args:
+            params: A parameter data.
+            run_id: A running stage ID. (Default is None)
+            event: An event manager that pass to the stage execution.
+                (Default is None)
 
-        :rtype: Result
+        Returns:
+            Result: The execution result with updated status and context.
         """
-        result: Result = Result.construct_with_rs_or_id(
-            result,
-            run_id=run_id,
-            parent_run_id=parent_run_id,
-            id_logic=self.iden,
-            extras=self.extras,
+        ts: float = time.monotonic()
+        parent_run_id: str = run_id
+        run_id: str = run_id or gen_id(self.iden, unique=True)
+        context: DictData = {}
+        trace: Trace = get_trace(
+            run_id, parent_run_id=parent_run_id, extras=self.extras
         )
         try:
-            result.trace.info(
+            _id: str = (
+                f" with ID: {param2template(self.id, params=params)!r}"
+                if self.id
+                else ""
+            )
+            trace.info(
                 f"[STAGE]: Handler {to_train(self.__class__.__name__)}: "
-                f"{self.name!r}."
+                f"{self.name!r}{_id}."
             )
 
             # NOTE: Show the description of this stage before execution.
             if self.desc:
-                result.trace.debug(f"[STAGE]: Description:||{self.desc}||")
+                trace.debug(f"[STAGE]: Description:||{self.desc}||")
 
             # VALIDATE: Checking stage condition before execution.
             if self.is_skipped(params):
@@ -287,13 +323,19 @@ class BaseStage(BaseModel, ABC):
             # NOTE: Start call wrapped execution method that will use custom
             #   execution before the real execution from inherit stage model.
             result_caught: Result = self._execute(
-                params, result=result, event=event
+                params,
+                run_id=run_id,
+                context=context,
+                parent_run_id=parent_run_id,
+                event=event,
             )
             if result_caught.status == WAIT:
                 raise StageError(
                     "Status from execution should not return waiting status."
                 )
-            return result_caught
+            return result_caught.make_info(
+                {"execution_time": time.monotonic() - ts}
+            )
 
         # NOTE: Catch this error in this line because the execution can raise
         #   this exception class at other location.
@@ -302,48 +344,82 @@ class BaseStage(BaseModel, ABC):
             StageCancelError,
             StageError,
         ) as e:  # pragma: no cov
-            result.trace.info(
+            trace.info(
                 f"[STAGE]: Handler:||{e.__class__.__name__}: {e}||"
                 f"{traceback.format_exc()}"
             )
-            return result.catch(
-                status=get_status_from_error(e),
-                context=(
-                    None
-                    if isinstance(e, StageSkipError)
-                    else {"errors": e.to_dict()}
+            st: Status = get_status_from_error(e)
+            return Result(
+                run_id=run_id,
+                parent_run_id=parent_run_id,
+                status=st,
+                context=catch(
+                    context,
+                    status=st,
+                    updated=(
+                        None
+                        if isinstance(e, StageSkipError)
+                        else {"errors": e.to_dict()}
+                    ),
                 ),
+                info={"execution_time": time.monotonic() - ts},
+                extras=self.extras,
             )
         except Exception as e:
-            result.trace.error(
+            trace.error(
                 f"[STAGE]: Error Handler:||{e.__class__.__name__}: {e}||"
                 f"{traceback.format_exc()}"
             )
-            return result.catch(status=FAILED, context={"errors": to_dict(e)})
+            return Result(
+                run_id=run_id,
+                parent_run_id=parent_run_id,
+                status=FAILED,
+                context=catch(
+                    context, status=FAILED, updated={"errors": to_dict(e)}
+                ),
+                info={"execution_time": time.monotonic() - ts},
+                extras=self.extras,
+            )
 
     def _execute(
-        self, params: DictData, result: Result, event: Optional[Event]
+        self,
+        params: DictData,
+        run_id: str,
+        context: DictData,
+        parent_run_id: Optional[str] = None,
+        event: Optional[Event] = None,
     ) -> Result:
-        """Wrapped the execute method before returning to handler execution.
+        """Wrapped the process method before returning to handler execution.
 
-        :param params: (DictData) A parameter data that want to use in this
-            execution.
-        :param result: (Result) A result object for keeping context and status
-            data.
-        :param event: (Event) An event manager that use to track parent execute
-            was not force stopped.
+        Args:
+            params: A parameter data that want to use in this
+                execution.
+            event: An event manager that use to track parent process
+                was not force stopped.
 
-        :rtype: Result
+        Returns:
+            Result: The wrapped execution result.
         """
-        result.catch(status=WAIT)
-        return self.execute(params, result=result, event=event)
+        catch(context, status=WAIT)
+        return self.process(
+            params,
+            run_id=run_id,
+            context=context,
+            parent_run_id=parent_run_id,
+            event=event,
+        )
 
-    def set_outputs(self, output: DictData, to: DictData) -> DictData:
+    def set_outputs(
+        self,
+        output: DictData,
+        to: DictData,
+        info: Optional[DictData] = None,
+    ) -> DictData:
         """Set an outputs from execution result context to the received context
         with a `to` input parameter. The result context from stage execution
         will be set with `outputs` key in this stage ID key.
 
-            For example of setting output method, If you receive execute output
+            For example of setting output method, If you receive process output
         and want to set on the `to` like;
 
             ... (i)   output: {'foo': 'bar', 'skipped': True}
@@ -374,6 +450,7 @@ class BaseStage(BaseModel, ABC):
         :param output: (DictData) A result data context that want to extract
             and transfer to the `outputs` key in receive context.
         :param to: (DictData) A received context data.
+        :param info: (DictData)
 
         :rtype: DictData
         """
@@ -393,7 +470,8 @@ class BaseStage(BaseModel, ABC):
         status: dict[str, Status] = (
             {"status": output.pop("status")} if "status" in output else {}
         )
-        to["stages"][_id] = {"outputs": output} | errors | status
+        info: DictData = {"info": info} if info else {}
+        to["stages"][_id] = {"outputs": output} | errors | status | info
         return to
 
     def get_outputs(self, output: DictData) -> DictData:
@@ -460,6 +538,7 @@ class BaseStage(BaseModel, ABC):
             param2template(self.id, params=params, extras=self.extras)
             if self.id
             else gen_id(
+                # NOTE: The name should be non-sensitive case for uniqueness.
                 param2template(self.name, params=params, extras=self.extras)
             )
         )
@@ -491,67 +570,74 @@ class BaseAsyncStage(BaseStage, ABC):
     """
 
     @abstractmethod
-    async def axecute(
+    async def async_process(
         self,
         params: DictData,
+        run_id: str,
+        context: DictData,
         *,
-        result: Optional[Result] = None,
+        parent_run_id: Optional[str] = None,
         event: Optional[Event] = None,
     ) -> Result:
         """Async execution method for this Empty stage that only logging out to
         stdout.
 
-        :param params: (DictData) A context data that want to add output result.
-            But this stage does not pass any output.
-        :param result: (Result) A result object for keeping context and status
-            data.
-        :param event: (Event) An event manager that use to track parent execute
-            was not force stopped.
-
-        :rtype: Result
+        Args:
+            params: A parameter data that want to use in this
+                execution.
+            run_id: A running stage ID.
+            context: A context data.
+            parent_run_id: A parent running ID. (Default is None)
+            event: An event manager that use to track parent process
+                was not force stopped.
+
+        Returns:
+            Result: The execution result with status and context data.
         """
         raise NotImplementedError(
             "Async Stage should implement `axecute` method."
         )
 
-    async def handler_axecute(
+    async def axecute(
         self,
         params: DictData,
         *,
         run_id: StrOrNone = None,
-        parent_run_id: StrOrNone = None,
-        result: Optional[Result] = None,
         event: Optional[Event] = None,
     ) -> Result:
         """Async Handler stage execution result from the stage `execute` method.
 
-        :param params: (DictData) A parameter data.
-        :param run_id: (str) A stage running ID.
-        :param parent_run_id: (str) A parent job running ID.
-        :param result: (Result) A Result instance for return context and status.
-        :param event: (Event) An Event manager instance that use to cancel this
-            execution if it forces stopped by parent execution.
+        Args:
+            params: A parameter data that want to use in this
+                execution.
+            run_id: A running stage ID. (Default is None)
+            event: An event manager that use to track parent process
+                was not force stopped.
 
-        :rtype: Result
+        Returns:
+            Result: The execution result with status and context data.
         """
-        result: Result = Result.construct_with_rs_or_id(
-            result,
-            run_id=run_id,
-            parent_run_id=parent_run_id,
-            id_logic=self.iden,
-            extras=self.extras,
+        ts: float = time.monotonic()
+        parent_run_id: StrOrNone = run_id
+        run_id: str = run_id or gen_id(self.iden, unique=True)
+        context: DictData = {}
+        trace: Trace = get_trace(
+            run_id, parent_run_id=parent_run_id, extras=self.extras
         )
         try:
-            await result.trace.ainfo(
+            _id: str = (
+                f" with ID: {param2template(self.id, params=params)!r}"
+                if self.id
+                else ""
+            )
+            await trace.ainfo(
                 f"[STAGE]: Handler {to_train(self.__class__.__name__)}: "
-                f"{self.name!r}."
+                f"{self.name!r}{_id}."
             )
 
             # NOTE: Show the description of this stage before execution.
             if self.desc:
-                await result.trace.adebug(
-                    f"[STAGE]: Description:||{self.desc}||"
-                )
+                await trace.adebug(f"[STAGE]: Description:||{self.desc}||")
 
             # VALIDATE: Checking stage condition before execution.
             if self.is_skipped(params=params):
@@ -562,7 +648,11 @@ class BaseAsyncStage(BaseStage, ABC):
             # NOTE: Start call wrapped execution method that will use custom
             #   execution before the real execution from inherit stage model.
             result_caught: Result = await self._axecute(
-                params, result=result, event=event
+                params,
+                run_id=run_id,
+                context=context,
+                parent_run_id=parent_run_id,
+                event=event,
             )
             if result_caught.status == WAIT:
                 raise StageError(
@@ -577,41 +667,68 @@ class BaseAsyncStage(BaseStage, ABC):
             StageCancelError,
             StageError,
         ) as e:  # pragma: no cov
-            await result.trace.ainfo(
+            await trace.ainfo(
                 f"[STAGE]: Skip Handler:||{e.__class__.__name__}: {e}||"
                 f"{traceback.format_exc()}"
             )
-            return result.catch(
-                status=get_status_from_error(e),
-                context=(
-                    {"errors": e.to_dict()}
-                    if isinstance(e, StageError)
-                    else None
+            st: Status = get_status_from_error(e)
+            return Result(
+                run_id=run_id,
+                parent_run_id=parent_run_id,
+                status=st,
+                context=catch(
+                    context,
+                    status=st,
+                    updated=(
+                        None
+                        if isinstance(e, StageSkipError)
+                        else {"status": st, "errors": e.to_dict()}
+                    ),
                 ),
+                info={"execution_time": time.monotonic() - ts},
+                extras=self.extras,
             )
         except Exception as e:
-            await result.trace.aerror(
+            await trace.aerror(
                 f"[STAGE]: Error Handler:||{e.__class__.__name__}: {e}||"
                 f"{traceback.format_exc()}"
             )
-            return result.catch(status=FAILED, context={"errors": to_dict(e)})
+            return Result(
+                run_id=run_id,
+                parent_run_id=parent_run_id,
+                status=FAILED,
+                context=catch(
+                    context, status=FAILED, updated={"errors": to_dict(e)}
+                ),
+                info={"execution_time": time.monotonic() - ts},
+                extras=self.extras,
+            )
 
     async def _axecute(
-        self, params: DictData, result: Result, event: Optional[Event]
+        self,
+        params: DictData,
+        run_id: str,
+        context: DictData,
+        parent_run_id: Optional[str] = None,
+        event: Optional[Event] = None,
     ) -> Result:
         """Wrapped the axecute method before returning to handler axecute.
 
         :param params: (DictData) A parameter data that want to use in this
             execution.
-        :param result: (Result) A result object for keeping context and status
-            data.
         :param event: (Event) An event manager that use to track parent execute
             was not force stopped.
 
         :rtype: Result
         """
-        result.catch(status=WAIT)
-        return await self.axecute(params, result=result, event=event)
+        catch(context, status=WAIT)
+        return await self.async_process(
+            params,
+            run_id=run_id,
+            context=context,
+            parent_run_id=parent_run_id,
+            event=event,
+        )
 
 
 class BaseRetryStage(BaseAsyncStage, ABC):  # pragma: no cov
@@ -629,16 +746,16 @@ class BaseRetryStage(BaseAsyncStage, ABC):  # pragma: no cov
     def _execute(
         self,
         params: DictData,
-        result: Result,
-        event: Optional[Event],
+        run_id: str,
+        context: DictData,
+        parent_run_id: Optional[str] = None,
+        event: Optional[Event] = None,
     ) -> Result:
         """Wrapped the execute method with retry strategy before returning to
         handler execute.
 
         :param params: (DictData) A parameter data that want to use in this
             execution.
-        :param result: (Result) A result object for keeping context and status
-            data.
         :param event: (Event) An event manager that use to track parent execute
             was not force stopped.
 
@@ -646,13 +763,18 @@ class BaseRetryStage(BaseAsyncStage, ABC):  # pragma: no cov
         """
         current_retry: int = 0
         exception: Exception
+        catch(context, status=WAIT)
+        trace: Trace = get_trace(
+            run_id, parent_run_id=parent_run_id, extras=self.extras
+        )
 
         # NOTE: First execution for not pass to retry step if it passes.
         try:
-            result.catch(status=WAIT)
-            return self.execute(
+            return self.process(
                 params | {"retry": current_retry},
-                result=result,
+                run_id=run_id,
+                context=context,
+                parent_run_id=parent_run_id,
                 event=event,
             )
         except Exception as e:
@@ -662,28 +784,34 @@ class BaseRetryStage(BaseAsyncStage, ABC):  # pragma: no cov
         if self.retry == 0:
             raise exception
 
-        result.trace.warning(
+        trace.warning(
             f"[STAGE]: Retry count: {current_retry} ... "
             f"( {exception.__class__.__name__} )"
         )
 
         while current_retry < (self.retry + 1):
             try:
-                result.catch(status=WAIT, context={"retry": current_retry})
-                return self.execute(
+                catch(
+                    context=context,
+                    status=WAIT,
+                    updated={"retry": current_retry},
+                )
+                return self.process(
                     params | {"retry": current_retry},
-                    result=result,
+                    run_id=run_id,
+                    context=context,
+                    parent_run_id=parent_run_id,
                     event=event,
                 )
             except Exception as e:
                 current_retry += 1
-                result.trace.warning(
+                trace.warning(
                     f"[STAGE]: Retry count: {current_retry} ... "
                     f"( {e.__class__.__name__} )"
                 )
                 exception = e
 
-        result.trace.error(
+        trace.error(
             f"[STAGE]: Reach the maximum of retry number: {self.retry}."
         )
         raise exception
@@ -691,16 +819,16 @@ class BaseRetryStage(BaseAsyncStage, ABC):  # pragma: no cov
     async def _axecute(
         self,
         params: DictData,
-        result: Result,
-        event: Optional[Event],
+        run_id: str,
+        context: DictData,
+        parent_run_id: Optional[str] = None,
+        event: Optional[Event] = None,
     ) -> Result:
         """Wrapped the axecute method with retry strategy before returning to
         handler axecute.
 
         :param params: (DictData) A parameter data that want to use in this
             execution.
-        :param result: (Result) A result object for keeping context and status
-            data.
         :param event: (Event) An event manager that use to track parent execute
             was not force stopped.
 
@@ -708,13 +836,18 @@ class BaseRetryStage(BaseAsyncStage, ABC):  # pragma: no cov
         """
         current_retry: int = 0
         exception: Exception
+        catch(context, status=WAIT)
+        trace: Trace = get_trace(
+            run_id, parent_run_id=parent_run_id, extras=self.extras
+        )
 
         # NOTE: First execution for not pass to retry step if it passes.
         try:
-            result.catch(status=WAIT)
-            return await self.axecute(
+            return await self.async_process(
                 params | {"retry": current_retry},
-                result=result,
+                run_id=run_id,
+                context=context,
+                parent_run_id=parent_run_id,
                 event=event,
             )
         except Exception as e:
@@ -724,47 +857,75 @@ class BaseRetryStage(BaseAsyncStage, ABC):  # pragma: no cov
         if self.retry == 0:
             raise exception
 
-        await result.trace.awarning(
+        await trace.awarning(
             f"[STAGE]: Retry count: {current_retry} ... "
             f"( {exception.__class__.__name__} )"
         )
 
         while current_retry < (self.retry + 1):
             try:
-                result.catch(status=WAIT, context={"retry": current_retry})
-                return await self.axecute(
+                catch(
+                    context=context,
+                    status=WAIT,
+                    updated={"retry": current_retry},
+                )
+                return await self.async_process(
                     params | {"retry": current_retry},
-                    result=result,
+                    run_id=run_id,
+                    context=context,
+                    parent_run_id=parent_run_id,
                     event=event,
                 )
             except Exception as e:
                 current_retry += 1
-                await result.trace.awarning(
+                await trace.awarning(
                     f"[STAGE]: Retry count: {current_retry} ... "
                     f"( {e.__class__.__name__} )"
                 )
                 exception = e
 
-        await result.trace.aerror(
+        await trace.aerror(
             f"[STAGE]: Reach the maximum of retry number: {self.retry}."
         )
         raise exception
 
 
 class EmptyStage(BaseAsyncStage):
-    """Empty stage executor that do nothing and log the `message` field to
-    stdout only. It can use for tracking a template parameter on the workflow or
-    debug step.
-
-        You can pass a sleep value in second unit to this stage for waiting
-    after log message.
-
-    Data Validate:
-        >>> stage = {
-        ...     "name": "Empty stage execution",
-        ...     "echo": "Hello World",
-        ...     "sleep": 1,
-        ... }
+    """Empty stage for logging and debugging workflows.
+
+    EmptyStage is a utility stage that performs no actual work but provides
+    logging output and optional delays. It's commonly used for:
+    - Debugging workflow execution flow
+    - Adding informational messages to workflows
+    - Creating delays between stages
+    - Testing template parameter resolution
+
+    The stage outputs the echo message to stdout and can optionally sleep
+    for a specified duration, making it useful for workflow timing control
+    and debugging scenarios.
+
+    Attributes:
+        echo (str, optional): Message to display during execution
+        sleep (float): Duration to sleep after logging (0-1800 seconds)
+
+    Example:
+        ```yaml
+        stages:
+          - name: "Workflow Started"
+            echo: "Beginning data processing workflow"
+            sleep: 2
+
+          - name: "Debug Parameters"
+            echo: "Processing file: ${{ params.filename }}"
+        ```
+
+        ```python
+        stage = EmptyStage(
+            name="Status Update",
+            echo="Processing completed successfully",
+            sleep=1.0
+        )
+        ```
     """
 
     echo: StrOrNone = Field(
@@ -781,11 +942,13 @@ class EmptyStage(BaseAsyncStage):
         lt=1800,
     )
 
-    def execute(
+    def process(
         self,
         params: DictData,
+        run_id: str,
+        context: DictData,
         *,
-        result: Optional[Result] = None,
+        parent_run_id: Optional[str] = None,
         event: Optional[Event] = None,
     ) -> Result:
         """Execution method for the Empty stage that do only logging out to
@@ -794,16 +957,20 @@ class EmptyStage(BaseAsyncStage):
             The result context should be empty and do not process anything
         without calling logging function.
 
-        :param params: (DictData) A parameter data.
-        :param result: (Result) A Result instance for return context and status.
-        :param event: (Event) An Event manager instance that use to cancel this
-            execution if it forces stopped by parent execution.
-
-        :rtype: Result
+        Args:
+            params: A parameter data that want to use in this
+                execution.
+            run_id: A running stage ID.
+            context: A context data.
+            parent_run_id: A parent running ID. (Default is None)
+            event: An event manager that use to track parent process
+                was not force stopped.
+
+        Returns:
+            Result: The execution result with status and context data.
         """
-        result: Result = result or Result(
-            run_id=gen_id(self.name + (self.id or ""), unique=True),
-            extras=self.extras,
+        trace: Trace = get_trace(
+            run_id, parent_run_id=parent_run_id, extras=self.extras
         )
         message: str = (
             param2template(
@@ -818,35 +985,46 @@ class EmptyStage(BaseAsyncStage):
                 "Execution was canceled from the event before start parallel."
             )
 
-        result.trace.info(f"[STAGE]: Message: ( {message} )")
+        trace.info(f"[STAGE]: Message: ( {message} )")
         if self.sleep > 0:
             if self.sleep > 5:
-                result.trace.info(f"[STAGE]: Sleep ... ({self.sleep} sec)")
+                trace.info(f"[STAGE]: Sleep ... ({self.sleep} sec)")
             time.sleep(self.sleep)
-        return result.catch(status=SUCCESS)
+        return Result(
+            run_id=run_id,
+            parent_run_id=parent_run_id,
+            status=SUCCESS,
+            context=catch(context=context, status=SUCCESS),
+            extras=self.extras,
+        )
 
-    async def axecute(
+    async def async_process(
         self,
         params: DictData,
+        run_id: str,
+        context: DictData,
         *,
-        result: Optional[Result] = None,
+        parent_run_id: Optional[str] = None,
         event: Optional[Event] = None,
     ) -> Result:
         """Async execution method for this Empty stage that only logging out to
         stdout.
 
-        :param params: (DictData) A parameter data.
-        :param result: (Result) A Result instance for return context and status.
-        :param event: (Event) An Event manager instance that use to cancel this
-            execution if it forces stopped by parent execution.
-
-        :rtype: Result
+        Args:
+            params: A parameter data that want to use in this
+                execution.
+            run_id: A running stage ID.
+            context: A context data.
+            parent_run_id: A parent running ID. (Default is None)
+            event: An event manager that use to track parent process
+                was not force stopped.
+
+        Returns:
+            Result: The execution result with status and context data.
         """
-        result: Result = result or Result(
-            run_id=gen_id(self.name + (self.id or ""), unique=True),
-            extras=self.extras,
+        trace: Trace = get_trace(
+            run_id, parent_run_id=parent_run_id, extras=self.extras
         )
-
         message: str = (
             param2template(
                 dedent(self.echo.strip("\n")), params, extras=self.extras
@@ -860,14 +1038,18 @@ class EmptyStage(BaseAsyncStage):
                 "Execution was canceled from the event before start parallel."
             )
 
-        result.trace.info(f"[STAGE]: Message: ( {message} )")
+        trace.info(f"[STAGE]: Message: ( {message} )")
         if self.sleep > 0:
             if self.sleep > 5:
-                await result.trace.ainfo(
-                    f"[STAGE]: Sleep ... ({self.sleep} sec)"
-                )
+                await trace.ainfo(f"[STAGE]: Sleep ... ({self.sleep} sec)")
             await asyncio.sleep(self.sleep)
-        return result.catch(status=SUCCESS)
+        return Result(
+            run_id=run_id,
+            parent_run_id=parent_run_id,
+            status=SUCCESS,
+            context=catch(context=context, status=SUCCESS),
+            extras=self.extras,
+        )
 
 
 class BashStage(BaseRetryStage):
@@ -975,27 +1157,38 @@ class BashStage(BaseRetryStage):
         # Note: Remove .sh file that use to run bash.
         Path(f"./{f_name}").unlink()
 
-    def execute(
+    @staticmethod
+    def prepare_std(value: str) -> Optional[str]:
+        """Prepare returned standard string from subprocess."""
+        return None if (out := value.strip("\n")) == "" else out
+
+    def process(
         self,
         params: DictData,
+        run_id: str,
+        context: DictData,
         *,
-        result: Optional[Result] = None,
+        parent_run_id: Optional[str] = None,
         event: Optional[Event] = None,
     ) -> Result:
         """Execute bash statement with the Python build-in `subprocess` package.
         It will catch result from the `subprocess.run` returning output like
         `return_code`, `stdout`, and `stderr`.
 
-        :param params: (DictData) A parameter data.
-        :param result: (Result) A Result instance for return context and status.
-        :param event: (Event) An Event manager instance that use to cancel this
-            execution if it forces stopped by parent execution.
-
-        :rtype: Result
+        Args:
+            params: A parameter data that want to use in this
+                execution.
+            run_id: A running stage ID.
+            context: A context data.
+            parent_run_id: A parent running ID. (Default is None)
+            event: An event manager that use to track parent process
+                was not force stopped.
+
+        Returns:
+            Result: The execution result with status and context data.
         """
-        result: Result = result or Result(
-            run_id=gen_id(self.name + (self.id or ""), unique=True),
-            extras=self.extras,
+        trace: Trace = get_trace(
+            run_id, parent_run_id=parent_run_id, extras=self.extras
         )
         bash: str = param2template(
             dedent(self.bash.strip("\n")), params, extras=self.extras
@@ -1003,9 +1196,9 @@ class BashStage(BaseRetryStage):
         with self.create_sh_file(
             bash=bash,
             env=param2template(self.env, params, extras=self.extras),
-            run_id=result.run_id,
+            run_id=run_id,
         ) as sh:
-            result.trace.debug(f"[STAGE]: Create `{sh[1]}` file.")
+            trace.debug(f"[STAGE]: Create `{sh[1]}` file.")
             rs: CompletedProcess = subprocess.run(
                 sh,
                 shell=False,
@@ -1018,35 +1211,48 @@ class BashStage(BaseRetryStage):
             e: str = rs.stderr.removesuffix("\n")
             e_bash: str = bash.replace("\n", "\n\t")
             raise StageError(f"Subprocess: {e}\n\t```bash\n\t{e_bash}\n\t```")
-        return result.catch(
+        return Result(
+            run_id=run_id,
+            parent_run_id=parent_run_id,
             status=SUCCESS,
-            context={
-                "return_code": rs.returncode,
-                "stdout": None if (out := rs.stdout.strip("\n")) == "" else out,
-                "stderr": None if (out := rs.stderr.strip("\n")) == "" else out,
-            },
+            context=catch(
+                context=context,
+                status=SUCCESS,
+                updated={
+                    "return_code": rs.returncode,
+                    "stdout": self.prepare_std(rs.stdout),
+                    "stderr": self.prepare_std(rs.stderr),
+                },
+            ),
+            extras=self.extras,
         )
 
-    async def axecute(
+    async def async_process(
         self,
         params: DictData,
+        run_id: str,
+        context: DictData,
         *,
-        result: Optional[Result] = None,
+        parent_run_id: Optional[str] = None,
         event: Optional[Event] = None,
     ) -> Result:
         """Async execution method for this Bash stage that only logging out to
         stdout.
 
-        :param params: (DictData) A parameter data.
-        :param result: (Result) A Result instance for return context and status.
-        :param event: (Event) An Event manager instance that use to cancel this
-            execution if it forces stopped by parent execution.
-
-        :rtype: Result
+        Args:
+            params: A parameter data that want to use in this
+                execution.
+            run_id: A running stage ID.
+            context: A context data.
+            parent_run_id: A parent running ID. (Default is None)
+            event: An event manager that use to track parent process
+                was not force stopped.
+
+        Returns:
+            Result: The execution result with status and context data.
         """
-        result: Result = result or Result(
-            run_id=gen_id(self.name + (self.id or ""), unique=True),
-            extras=self.extras,
+        trace: Trace = get_trace(
+            run_id, parent_run_id=parent_run_id, extras=self.extras
         )
         bash: str = param2template(
             dedent(self.bash.strip("\n")), params, extras=self.extras
@@ -1054,9 +1260,9 @@ class BashStage(BaseRetryStage):
         async with self.async_create_sh_file(
             bash=bash,
             env=param2template(self.env, params, extras=self.extras),
-            run_id=result.run_id,
+            run_id=run_id,
         ) as sh:
-            await result.trace.adebug(f"[STAGE]: Create `{sh[1]}` file.")
+            await trace.adebug(f"[STAGE]: Create `{sh[1]}` file.")
             rs: CompletedProcess = subprocess.run(
                 sh,
                 shell=False,
@@ -1070,13 +1276,20 @@ class BashStage(BaseRetryStage):
             e: str = rs.stderr.removesuffix("\n")
             e_bash: str = bash.replace("\n", "\n\t")
             raise StageError(f"Subprocess: {e}\n\t```bash\n\t{e_bash}\n\t```")
-        return result.catch(
+        return Result(
+            run_id=run_id,
+            parent_run_id=parent_run_id,
             status=SUCCESS,
-            context={
-                "return_code": rs.returncode,
-                "stdout": None if (out := rs.stdout.strip("\n")) == "" else out,
-                "stderr": None if (out := rs.stderr.strip("\n")) == "" else out,
-            },
+            context=catch(
+                context=context,
+                status=SUCCESS,
+                updated={
+                    "return_code": rs.returncode,
+                    "stdout": self.prepare_std(rs.stdout),
+                    "stderr": self.prepare_std(rs.stderr),
+                },
+            ),
+            extras=self.extras,
         )
 
 
@@ -1135,13 +1348,16 @@ class PyStage(BaseRetryStage):
 
             yield value
 
-    def set_outputs(self, output: DictData, to: DictData) -> DictData:
+    def set_outputs(
+        self, output: DictData, to: DictData, info: Optional[DictData] = None
+    ) -> DictData:
         """Override set an outputs method for the Python execution process that
         extract output from all the locals values.
 
         :param output: (DictData) An output data that want to extract to an
             output key.
         :param to: (DictData) A context data that want to add output result.
+        :param info: (DictData)
 
         :rtype: DictData
         """
@@ -1152,33 +1368,47 @@ class PyStage(BaseRetryStage):
         to.update({k: gb[k] for k in to if k in gb})
         return to
 
-    def execute(
+    def process(
         self,
         params: DictData,
+        run_id: str,
+        context: DictData,
         *,
-        result: Optional[Result] = None,
+        parent_run_id: Optional[str] = None,
         event: Optional[Event] = None,
     ) -> Result:
         """Execute the Python statement that pass all globals and input params
         to globals argument on `exec` build-in function.
 
-        :param params: (DictData) A parameter data.
-        :param result: (Result) A result object for keeping context and status
-            data.
-        :param event: (Event) An event manager that use to track parent execute
-            was not force stopped.
-
-        :rtype: Result
+        Args:
+            params: A parameter data that want to use in this
+                execution.
+            run_id: A running stage ID.
+            context: A context data.
+            parent_run_id: A parent running ID. (Default is None)
+            event: An event manager that use to track parent process
+                was not force stopped.
+
+        Returns:
+            Result: The execution result with status and context data.
         """
-        result: Result = result or Result(
-            run_id=gen_id(self.name + (self.id or ""), unique=True),
-            extras=self.extras,
+        trace: Trace = get_trace(
+            run_id, parent_run_id=parent_run_id, extras=self.extras
         )
+        trace.info("[STAGE]: Prepare `globals` and `locals` variables.")
         lc: DictData = {}
         gb: DictData = (
             globals()
             | param2template(self.vars, params, extras=self.extras)
-            | {"result": result}
+            | {
+                "result": Result(
+                    run_id=run_id,
+                    parent_run_id=parent_run_id,
+                    status=WAIT,
+                    context=context,
+                    extras=self.extras,
+                )
+            }
         )
 
         # WARNING: The exec build-in function is very dangerous. So, it
@@ -1190,55 +1420,76 @@ class PyStage(BaseRetryStage):
             gb,
             lc,
         )
-
-        return result.catch(
+        return Result(
+            run_id=run_id,
+            parent_run_id=parent_run_id,
             status=SUCCESS,
-            context={
-                "locals": {k: lc[k] for k in self.filter_locals(lc)},
-                "globals": {
-                    k: gb[k]
-                    for k in gb
-                    if (
-                        not k.startswith("__")
-                        and k != "annotations"
-                        and not ismodule(gb[k])
-                        and not isclass(gb[k])
-                        and not isfunction(gb[k])
-                        and k in params
-                    )
+            context=catch(
+                context=context,
+                status=SUCCESS,
+                updated={
+                    "locals": {k: lc[k] for k in self.filter_locals(lc)},
+                    "globals": {
+                        k: gb[k]
+                        for k in gb
+                        if (
+                            not k.startswith("__")
+                            and k != "annotations"
+                            and not ismodule(gb[k])
+                            and not isclass(gb[k])
+                            and not isfunction(gb[k])
+                            and k in params
+                        )
+                    },
                 },
-            },
+            ),
+            extras=self.extras,
         )
 
-    async def axecute(
+    async def async_process(
         self,
         params: DictData,
+        run_id: str,
+        context: DictData,
         *,
-        result: Optional[Result] = None,
+        parent_run_id: Optional[str] = None,
         event: Optional[Event] = None,
     ) -> Result:
         """Async execution method for this Bash stage that only logging out to
         stdout.
 
-        :param params: (DictData) A parameter data.
-        :param result: (Result) A Result instance for return context and status.
-        :param event: (Event) An Event manager instance that use to cancel this
-            execution if it forces stopped by parent execution.
-
         References:
             - https://stackoverflow.com/questions/44859165/async-exec-in-python
 
-        :rtype: Result
+        Args:
+            params: A parameter data that want to use in this
+                execution.
+            run_id: A running stage ID.
+            context: A context data.
+            parent_run_id: A parent running ID. (Default is None)
+            event: An event manager that use to track parent process
+                was not force stopped.
+
+        Returns:
+            Result: The execution result with status and context data.
         """
-        result: Result = result or Result(
-            run_id=gen_id(self.name + (self.id or ""), unique=True),
-            extras=self.extras,
+        trace: Trace = get_trace(
+            run_id, parent_run_id=parent_run_id, extras=self.extras
         )
+        await trace.ainfo("[STAGE]: Prepare `globals` and `locals` variables.")
         lc: DictData = {}
         gb: DictData = (
             globals()
             | param2template(self.vars, params, extras=self.extras)
-            | {"result": result}
+            | {
+                "result": Result(
+                    run_id=run_id,
+                    parent_run_id=parent_run_id,
+                    status=WAIT,
+                    context=context,
+                    extras=self.extras,
+                )
+            }
         )
         # WARNING: The exec build-in function is very dangerous. So, it
         #   should use the re module to validate exec-string before running.
@@ -1247,23 +1498,30 @@ class PyStage(BaseRetryStage):
             gb,
             lc,
         )
-        return result.catch(
+        return Result(
+            run_id=run_id,
+            parent_run_id=parent_run_id,
             status=SUCCESS,
-            context={
-                "locals": {k: lc[k] for k in self.filter_locals(lc)},
-                "globals": {
-                    k: gb[k]
-                    for k in gb
-                    if (
-                        not k.startswith("__")
-                        and k != "annotations"
-                        and not ismodule(gb[k])
-                        and not isclass(gb[k])
-                        and not isfunction(gb[k])
-                        and k in params
-                    )
+            context=catch(
+                context=context,
+                status=SUCCESS,
+                updated={
+                    "locals": {k: lc[k] for k in self.filter_locals(lc)},
+                    "globals": {
+                        k: gb[k]
+                        for k in gb
+                        if (
+                            not k.startswith("__")
+                            and k != "annotations"
+                            and not ismodule(gb[k])
+                            and not isclass(gb[k])
+                            and not isfunction(gb[k])
+                            and k in params
+                        )
+                    },
                 },
-            },
+            ),
+            extras=self.extras,
         )
 
 
@@ -1311,46 +1569,69 @@ class CallStage(BaseRetryStage):
         alias="with",
     )
 
-    def execute(
+    @field_validator("args", mode="before")
+    def __validate_args_key(cls, value: Any) -> Any:
+        """Validate argument keys on the ``args`` field should not include the
+        special keys.
+
+        :param value: (Any) A value that want to check the special keys.
+
+        :rtype: Any
+        """
+        if isinstance(value, dict):
+            if any(k in value for k in ("result", "extras")):
+                raise ValueError(
+                    "The argument on workflow template for the caller stage "
+                    "should not pass `result` and `extras`. They are special "
+                    "arguments."
+                )
+        return value
+
+    def process(
         self,
         params: DictData,
+        run_id: str,
+        context: DictData,
         *,
-        result: Optional[Result] = None,
+        parent_run_id: Optional[str] = None,
         event: Optional[Event] = None,
     ) -> Result:
         """Execute this caller function with its argument parameter.
 
-        :param params: (DictData) A parameter data.
-        :param result: (Result) A Result instance for return context and status.
-        :param event: (Event) An Event manager instance that use to cancel this
-            execution if it forces stopped by parent execution.
-
-        :raise ValueError: If necessary arguments does not pass from the `args`
-            field.
-        :raise TypeError: If the result from the caller function does not match
-            with a `dict` type.
-
-        :rtype: Result
+        Args:
+            params: A parameter data that want to use in this
+                execution.
+            run_id: A running stage ID.
+            context: A context data.
+            parent_run_id: A parent running ID. (Default is None)
+            event: An event manager that use to track parent process
+                was not force stopped.
+
+        Returns:
+            Result: The execution result with status and context data.
         """
-        result: Result = result or Result(
-            run_id=gen_id(self.name + (self.id or ""), unique=True),
-            extras=self.extras,
+        trace: Trace = get_trace(
+            run_id, parent_run_id=parent_run_id, extras=self.extras
         )
-
         call_func: TagFunc = extract_call(
             param2template(self.uses, params, extras=self.extras),
             registries=self.extras.get("registry_caller"),
         )()
 
-        result.trace.info(
-            f"[STAGE]: Caller Func: '{call_func.name}@{call_func.tag}'"
-        )
+        trace.info(f"[STAGE]: Caller Func: '{call_func.name}@{call_func.tag}'")
 
         # VALIDATE: check input task caller parameters that exists before
         #   calling.
-        args: DictData = {"result": result} | param2template(
-            self.args, params, extras=self.extras
-        )
+        args: DictData = {
+            "result": Result(
+                run_id=run_id,
+                parent_run_id=parent_run_id,
+                status=WAIT,
+                context=context,
+                extras=self.extras,
+            ),
+            "extras": self.extras,
+        } | param2template(self.args, params, extras=self.extras)
         sig = inspect.signature(call_func)
         necessary_params: list[str] = []
         has_keyword: bool = False
@@ -1369,20 +1650,33 @@ class CallStage(BaseRetryStage):
             (k.removeprefix("_") not in args and k not in args)
             for k in necessary_params
         ):
+            if "result" in necessary_params:
+                necessary_params.remove("result")
+
+            if "extras" in necessary_params:
+                necessary_params.remove("extras")
+
+            args.pop("result")
+            args.pop("extras")
             raise ValueError(
                 f"Necessary params, ({', '.join(necessary_params)}, ), "
-                f"does not set to args, {list(args.keys())}."
+                f"does not set to args. It already set {list(args.keys())}."
             )
 
         if "result" not in sig.parameters and not has_keyword:
             args.pop("result")
 
+        if "extras" not in sig.parameters and not has_keyword:
+            args.pop("extras")
+
         if event and event.is_set():
             raise StageCancelError(
                 "Execution was canceled from the event before start parallel."
             )
 
-        args = self.validate_model_args(call_func, args, result)
+        args: DictData = self.validate_model_args(
+            call_func, args, run_id, parent_run_id
+        )
         if inspect.iscoroutinefunction(call_func):
             loop = asyncio.get_event_loop()
             rs: DictData = loop.run_until_complete(
@@ -1403,47 +1697,66 @@ class CallStage(BaseRetryStage):
                 f"serialize, you must set return be `dict` or Pydantic "
                 f"model."
             )
-        return result.catch(status=SUCCESS, context=rs)
+        return Result(
+            run_id=run_id,
+            parent_run_id=parent_run_id,
+            status=SUCCESS,
+            context=catch(
+                context=context,
+                status=SUCCESS,
+                updated=dump_all(rs, by_alias=True),
+            ),
+            extras=self.extras,
+        )
 
-    async def axecute(
+    async def async_process(
         self,
         params: DictData,
+        run_id: str,
+        context: DictData,
         *,
-        result: Optional[Result] = None,
+        parent_run_id: Optional[str] = None,
         event: Optional[Event] = None,
     ) -> Result:
         """Async execution method for this Bash stage that only logging out to
         stdout.
 
-        :param params: (DictData) A parameter data.
-        :param result: (Result) A Result instance for return context and status.
-        :param event: (Event) An Event manager instance that use to cancel this
-            execution if it forces stopped by parent execution.
-
-        References:
-            - https://stackoverflow.com/questions/44859165/async-exec-in-python
-
-        :rtype: Result
+        Args:
+            params: A parameter data that want to use in this
+                execution.
+            run_id: A running stage ID.
+            context: A context data.
+            parent_run_id: A parent running ID. (Default is None)
+            event: An event manager that use to track parent process
+                was not force stopped.
+
+        Returns:
+            Result: The execution result with status and context data.
         """
-        result: Result = result or Result(
-            run_id=gen_id(self.name + (self.id or ""), unique=True),
-            extras=self.extras,
+        trace: Trace = get_trace(
+            run_id, parent_run_id=parent_run_id, extras=self.extras
         )
-
         call_func: TagFunc = extract_call(
             param2template(self.uses, params, extras=self.extras),
             registries=self.extras.get("registry_caller"),
         )()
 
-        await result.trace.ainfo(
+        await trace.ainfo(
             f"[STAGE]: Caller Func: '{call_func.name}@{call_func.tag}'"
         )
 
         # VALIDATE: check input task caller parameters that exists before
         #   calling.
-        args: DictData = {"result": result} | param2template(
-            self.args, params, extras=self.extras
-        )
+        args: DictData = {
+            "result": Result(
+                run_id=run_id,
+                parent_run_id=parent_run_id,
+                status=WAIT,
+                context=context,
+                extras=self.extras,
+            ),
+            "extras": self.extras,
+        } | param2template(self.args, params, extras=self.extras)
         sig = inspect.signature(call_func)
         necessary_params: list[str] = []
         has_keyword: bool = False
@@ -1462,15 +1775,27 @@ class CallStage(BaseRetryStage):
             (k.removeprefix("_") not in args and k not in args)
             for k in necessary_params
         ):
+            if "result" in necessary_params:
+                necessary_params.remove("result")
+
+            if "extras" in necessary_params:
+                necessary_params.remove("extras")
+
+            args.pop("result")
+            args.pop("extras")
             raise ValueError(
                 f"Necessary params, ({', '.join(necessary_params)}, ), "
-                f"does not set to args, {list(args.keys())}."
+                f"does not set to args. It already set {list(args.keys())}."
             )
-
         if "result" not in sig.parameters and not has_keyword:
             args.pop("result")
 
-        args: DictData = self.validate_model_args(call_func, args, result)
+        if "extras" not in sig.parameters and not has_keyword:
+            args.pop("extras")
+
+        args: DictData = self.validate_model_args(
+            call_func, args, run_id, parent_run_id
+        )
         if inspect.iscoroutinefunction(call_func):
             rs: DictOrModel = await call_func(
                 **param2template(args, params, extras=self.extras)
@@ -1490,20 +1815,31 @@ class CallStage(BaseRetryStage):
                 f"serialize, you must set return be `dict` or Pydantic "
                 f"model."
             )
-        return result.catch(status=SUCCESS, context=dump_all(rs, by_alias=True))
+        return Result(
+            run_id=run_id,
+            parent_run_id=parent_run_id,
+            status=SUCCESS,
+            context=catch(
+                context=context,
+                status=SUCCESS,
+                updated=dump_all(rs, by_alias=True),
+            ),
+            extras=self.extras,
+        )
 
-    @staticmethod
     def validate_model_args(
+        self,
         func: TagFunc,
         args: DictData,
-        result: Result,
+        run_id: str,
+        parent_run_id: Optional[str] = None,
     ) -> DictData:
         """Validate an input arguments before passing to the caller function.
 
-        :param func: (TagFunc) A tag function that want to get typing.
-        :param args: (DictData) An arguments before passing to this tag func.
-        :param result: (Result) A result object for keeping context and status
-            data.
+        Args:
+            func: (TagFunc) A tag function that want to get typing.
+            args: (DictData) An arguments before passing to this tag func.
+            run_id: A running stage ID.
 
         :rtype: DictData
         """
@@ -1529,7 +1865,10 @@ class CallStage(BaseRetryStage):
                 "Validate argument from the caller function raise invalid type."
             ) from e
         except TypeError as e:
-            result.trace.warning(
+            trace: Trace = get_trace(
+                run_id, parent_run_id=parent_run_id, extras=self.extras
+            )
+            trace.warning(
                 f"[STAGE]: Get type hint raise TypeError: {e}, so, it skip "
                 f"parsing model args process."
             )
@@ -1541,7 +1880,9 @@ class BaseNestedStage(BaseRetryStage, ABC):
     is the nested stage or not.
     """
 
-    def set_outputs(self, output: DictData, to: DictData) -> DictData:
+    def set_outputs(
+        self, output: DictData, to: DictData, info: Optional[DictData] = None
+    ) -> DictData:
         """Override the set outputs method that support for nested-stage."""
         return super().set_outputs(output, to=to)
 
@@ -1570,13 +1911,29 @@ class BaseNestedStage(BaseRetryStage, ABC):
         else:
             context["errors"] = error.to_dict(with_refs=True)
 
-    async def axecute(
+    async def async_process(
         self,
         params: DictData,
+        run_id: str,
+        context: DictData,
         *,
-        result: Optional[Result] = None,
+        parent_run_id: Optional[str] = None,
         event: Optional[Event] = None,
     ) -> Result:
+        """Async process for nested-stage do not implement yet.
+
+        Args:
+            params: A parameter data that want to use in this
+                execution.
+            run_id: A running stage ID.
+            context: A context data.
+            parent_run_id: A parent running ID. (Default is None)
+            event: An event manager that use to track parent process
+                was not force stopped.
+
+        Returns:
+            Result: The execution result with status and context data.
+        """
         raise NotImplementedError(
             "The nested-stage does not implement the `axecute` method yet."
         )
@@ -1606,41 +1963,45 @@ class TriggerStage(BaseNestedStage):
         description="A parameter that will pass to workflow execution method.",
     )
 
-    def execute(
+    def process(
         self,
         params: DictData,
+        run_id: str,
+        context: DictData,
         *,
-        result: Optional[Result] = None,
+        parent_run_id: Optional[str] = None,
         event: Optional[Event] = None,
     ) -> Result:
         """Trigger another workflow execution. It will wait the trigger
         workflow running complete before catching its result and raise error
         when the result status does not be SUCCESS.
 
-        :param params: (DictData) A parameter data.
-        :param result: (Result) A result object for keeping context and status
-            data. (Default is None)
-        :param event: (Event) An event manager that use to track parent execute
-            was not force stopped. (Default is None)
-
-        :rtype: Result
+        Args:
+            params: A parameter data that want to use in this
+                execution.
+            run_id: A running stage ID.
+            context: A context data.
+            parent_run_id: A parent running ID. (Default is None)
+            event: An event manager that use to track parent process
+                was not force stopped.
+
+        Returns:
+            Result: The execution result with status and context data.
         """
         from .workflow import Workflow
 
-        result: Result = result or Result(
-            run_id=gen_id(self.name + (self.id or ""), unique=True),
-            extras=self.extras,
+        trace: Trace = get_trace(
+            run_id, parent_run_id=parent_run_id, extras=self.extras
         )
-
         _trigger: str = param2template(self.trigger, params, extras=self.extras)
+        trace.info(f"[STAGE]: Load workflow: {_trigger!r}")
         result: Result = Workflow.from_conf(
             name=pass_env(_trigger),
             extras=self.extras,
         ).execute(
             # NOTE: Should not use the `pass_env` function on this params parameter.
             params=param2template(self.params, params, extras=self.extras),
-            run_id=None,
-            parent_run_id=result.parent_run_id,
+            run_id=parent_run_id,
             event=event,
         )
         if result.status == FAILED:
@@ -1705,20 +2066,24 @@ class ParallelStage(BaseNestedStage):
         alias="max-workers",
     )
 
-    def execute_branch(
+    def _process_branch(
         self,
         branch: str,
         params: DictData,
-        result: Result,
+        run_id: str,
+        context: DictData,
         *,
+        parent_run_id: Optional[str] = None,
         event: Optional[Event] = None,
-    ) -> tuple[Status, Result]:
+    ) -> tuple[Status, DictData]:
         """Execute branch that will execute all nested-stage that was set in
         this stage with specific branch ID.
 
         :param branch: (str) A branch ID.
         :param params: (DictData) A parameter data.
-        :param result: (Result) A Result instance for return context and status.
+        :param run_id: (str)
+        :param context: (DictData)
+        :param parent_run_id: (str | None)
         :param event: (Event) An Event manager instance that use to cancel this
             execution if it forces stopped by parent execution.
             (Default is None)
@@ -1728,13 +2093,16 @@ class ParallelStage(BaseNestedStage):
             status.
         :raise StageError: If result from a nested-stage return failed status.
 
-        :rtype: tuple[Status, Result]
+        :rtype: tuple[Status, DictData]
         """
-        result.trace.debug(f"[STAGE]: Execute Branch: {branch!r}")
+        trace: Trace = get_trace(
+            run_id, parent_run_id=parent_run_id, extras=self.extras
+        )
+        trace.debug(f"[STAGE]: Execute Branch: {branch!r}")
 
         # NOTE: Create nested-context
-        context: DictData = copy.deepcopy(params)
-        context.update({"branch": branch})
+        current_context: DictData = copy.deepcopy(params)
+        current_context.update({"branch": branch})
         nestet_context: DictData = {"branch": branch, "stages": {}}
 
         total_stage: int = len(self.parallel[branch])
@@ -1749,7 +2117,8 @@ class ParallelStage(BaseNestedStage):
                     "Branch execution was canceled from the event before "
                     "start branch execution."
                 )
-                result.catch(
+                catch(
+                    context=context,
                     status=CANCEL,
                     parallel={
                         branch: {
@@ -1764,14 +2133,15 @@ class ParallelStage(BaseNestedStage):
                 )
                 raise StageCancelError(error_msg, refs=branch)
 
-            rs: Result = stage.handler_execute(
-                params=context,
-                run_id=result.run_id,
-                parent_run_id=result.parent_run_id,
+            rs: Result = stage.execute(
+                params=current_context,
+                run_id=parent_run_id,
                 event=event,
             )
             stage.set_outputs(rs.context, to=nestet_context)
-            stage.set_outputs(stage.get_outputs(nestet_context), to=context)
+            stage.set_outputs(
+                stage.get_outputs(nestet_context), to=current_context
+            )
 
             if rs.status == SKIP:
                 skips[i] = True
@@ -1782,7 +2152,8 @@ class ParallelStage(BaseNestedStage):
                     f"Branch execution was break because its nested-stage, "
                     f"{stage.iden!r}, failed."
                 )
-                result.catch(
+                catch(
+                    context=context,
                     status=FAILED,
                     parallel={
                         branch: {
@@ -1802,7 +2173,8 @@ class ParallelStage(BaseNestedStage):
                     "Branch execution was canceled from the event after "
                     "end branch execution."
                 )
-                result.catch(
+                catch(
+                    context=context,
                     status=CANCEL,
                     parallel={
                         branch: {
@@ -1818,7 +2190,8 @@ class ParallelStage(BaseNestedStage):
                 raise StageCancelError(error_msg, refs=branch)
 
         status: Status = SKIP if sum(skips) == total_stage else SUCCESS
-        return status, result.catch(
+        return status, catch(
+            context=context,
             status=status,
             parallel={
                 branch: {
@@ -1829,32 +2202,38 @@ class ParallelStage(BaseNestedStage):
             },
         )
 
-    def execute(
+    def process(
         self,
         params: DictData,
+        run_id: str,
+        context: DictData,
         *,
-        result: Optional[Result] = None,
+        parent_run_id: Optional[str] = None,
         event: Optional[Event] = None,
     ) -> Result:
         """Execute parallel each branch via multi-threading pool.
 
-        :param params: (DictData) A parameter data.
-        :param result: (Result) A Result instance for return context and status.
-        :param event: (Event) An Event manager instance that use to cancel this
-            execution if it forces stopped by parent execution.
-            (Default is None)
-
-        :rtype: Result
+        Args:
+            params: A parameter data that want to use in this
+                execution.
+            run_id: A running stage ID.
+            context: A context data.
+            parent_run_id: A parent running ID. (Default is None)
+            event: An event manager that use to track parent process
+                was not force stopped.
+
+        Returns:
+            Result: The execution result with status and context data.
         """
-        result: Result = result or Result(
-            run_id=gen_id(self.name + (self.id or ""), unique=True),
-            extras=self.extras,
+        trace: Trace = get_trace(
+            run_id, parent_run_id=parent_run_id, extras=self.extras
         )
         event: Event = event or Event()
-        result.trace.info(f"[STAGE]: Parallel with {self.max_workers} workers.")
-        result.catch(
+        trace.info(f"[STAGE]: Parallel with {self.max_workers} workers.")
+        catch(
+            context=context,
             status=WAIT,
-            context={"workers": self.max_workers, "parallel": {}},
+            updated={"workers": self.max_workers, "parallel": {}},
         )
         len_parallel: int = len(self.parallel)
         if event and event.is_set():
@@ -1865,25 +2244,32 @@ class ParallelStage(BaseNestedStage):
         with ThreadPoolExecutor(self.max_workers, "stp") as executor:
             futures: list[Future] = [
                 executor.submit(
-                    self.execute_branch,
+                    self._process_branch,
                     branch=branch,
                     params=params,
-                    result=result,
+                    run_id=run_id,
+                    context=context,
+                    parent_run_id=parent_run_id,
                     event=event,
                 )
                 for branch in self.parallel
             ]
-            context: DictData = {}
+            errors: DictData = {}
             statuses: list[Status] = [WAIT] * len_parallel
             for i, future in enumerate(as_completed(futures), start=0):
                 try:
                     statuses[i], _ = future.result()
                 except StageError as e:
                     statuses[i] = get_status_from_error(e)
-                    self.mark_errors(context, e)
-        return result.catch(
-            status=validate_statuses(statuses),
-            context=context,
+                    self.mark_errors(errors, e)
+
+        st: Status = validate_statuses(statuses)
+        return Result(
+            run_id=run_id,
+            parent_run_id=parent_run_id,
+            status=st,
+            context=catch(context, status=st, updated=errors),
+            extras=self.extras,
         )
 
 
@@ -1936,15 +2322,17 @@ class ForEachStage(BaseNestedStage):
         ),
     )
 
-    def execute_item(
+    def _process_item(
         self,
         index: int,
         item: StrOrInt,
         params: DictData,
-        result: Result,
+        run_id: str,
+        context: DictData,
         *,
+        parent_run_id: Optional[str] = None,
         event: Optional[Event] = None,
-    ) -> tuple[Status, Result]:
+    ) -> tuple[Status, DictData]:
         """Execute item that will execute all nested-stage that was set in this
         stage with specific foreach item.
 
@@ -1954,7 +2342,9 @@ class ForEachStage(BaseNestedStage):
         :param index: (int) An index value of foreach loop.
         :param item: (str | int) An item that want to execution.
         :param params: (DictData) A parameter data.
-        :param result: (Result) A Result instance for return context and status.
+        :param run_id: (str)
+        :param context: (DictData)
+        :param parent_run_id: (str | None)
         :param event: (Event) An Event manager instance that use to cancel this
             execution if it forces stopped by parent execution.
             (Default is None)
@@ -1968,12 +2358,15 @@ class ForEachStage(BaseNestedStage):
 
         :rtype: tuple[Status, Result]
         """
-        result.trace.debug(f"[STAGE]: Execute Item: {item!r}")
+        trace: Trace = get_trace(
+            run_id, parent_run_id=parent_run_id, extras=self.extras
+        )
+        trace.debug(f"[STAGE]: Execute Item: {item!r}")
         key: StrOrInt = index if self.use_index_as_key else item
 
         # NOTE: Create nested-context data from the passing context.
-        context: DictData = copy.deepcopy(params)
-        context.update({"item": item, "loop": index})
+        current_context: DictData = copy.deepcopy(params)
+        current_context.update({"item": item, "loop": index})
         nestet_context: DictData = {"item": item, "stages": {}}
 
         total_stage: int = len(self.stages)
@@ -1988,7 +2381,8 @@ class ForEachStage(BaseNestedStage):
                     "Item execution was canceled from the event before start "
                     "item execution."
                 )
-                result.catch(
+                catch(
+                    context=context,
                     status=CANCEL,
                     foreach={
                         key: {
@@ -2003,14 +2397,16 @@ class ForEachStage(BaseNestedStage):
                 )
                 raise StageCancelError(error_msg, refs=key)
 
-            rs: Result = stage.handler_execute(
-                params=context,
-                run_id=result.run_id,
-                parent_run_id=result.parent_run_id,
+            # NOTE: Nested-stage execute will pass only params and context only.
+            rs: Result = stage.execute(
+                params=current_context,
+                run_id=parent_run_id,
                 event=event,
             )
             stage.set_outputs(rs.context, to=nestet_context)
-            stage.set_outputs(stage.get_outputs(nestet_context), to=context)
+            stage.set_outputs(
+                stage.get_outputs(nestet_context), to=current_context
+            )
 
             if rs.status == SKIP:
                 skips[i] = True
@@ -2021,8 +2417,9 @@ class ForEachStage(BaseNestedStage):
                     f"Item execution was break because its nested-stage, "
                     f"{stage.iden!r}, failed."
                 )
-                result.trace.warning(f"[STAGE]: {error_msg}")
-                result.catch(
+                trace.warning(f"[STAGE]: {error_msg}")
+                catch(
+                    context=context,
                     status=FAILED,
                     foreach={
                         key: {
@@ -2042,7 +2439,8 @@ class ForEachStage(BaseNestedStage):
                     "Item execution was canceled from the event after "
                     "end item execution."
                 )
-                result.catch(
+                catch(
+                    context=context,
                     status=CANCEL,
                     foreach={
                         key: {
@@ -2058,7 +2456,8 @@ class ForEachStage(BaseNestedStage):
                 raise StageCancelError(error_msg, refs=key)
 
         status: Status = SKIP if sum(skips) == total_stage else SUCCESS
-        return status, result.catch(
+        return status, catch(
+            context=context,
             status=status,
             foreach={
                 key: {
@@ -2069,11 +2468,13 @@ class ForEachStage(BaseNestedStage):
             },
         )
 
-    def execute(
+    def process(
         self,
         params: DictData,
+        run_id: str,
+        context: DictData,
         *,
-        result: Optional[Result] = None,
+        parent_run_id: Optional[str] = None,
         event: Optional[Event] = None,
     ) -> Result:
         """Execute the stages that pass each item form the foreach field.
@@ -2082,18 +2483,20 @@ class ForEachStage(BaseNestedStage):
         value more than 1. It will cancel all nested-stage execution when it has
         any item loop raise failed or canceled error.
 
-        :param params: (DictData) A parameter data.
-        :param result: (Result) A Result instance for return context and status.
-        :param event: (Event) An Event manager instance that use to cancel this
-            execution if it forces stopped by parent execution.
-
-        :raise TypeError: If the foreach does not match with type list.
-
-        :rtype: Result
+        Args:
+            params: A parameter data that want to use in this
+                execution.
+            run_id: A running stage ID.
+            context: A context data.
+            parent_run_id: A parent running ID. (Default is None)
+            event: An event manager that use to track parent process
+                was not force stopped.
+
+        Returns:
+            Result: The execution result with status and context data.
         """
-        result: Result = result or Result(
-            run_id=gen_id(self.name + (self.id or ""), unique=True),
-            extras=self.extras,
+        trace: Trace = get_trace(
+            run_id, parent_run_id=parent_run_id, extras=self.extras
         )
         event: Event = event or Event()
         foreach: Union[list[str], list[int]] = pass_env(
@@ -2123,8 +2526,12 @@ class ForEachStage(BaseNestedStage):
                 "duplicate item, it should set `use_index_as_key: true`."
             )
 
-        result.trace.info(f"[STAGE]: Foreach: {foreach!r}.")
-        result.catch(status=WAIT, context={"items": foreach, "foreach": {}})
+        trace.info(f"[STAGE]: Foreach: {foreach!r}.")
+        catch(
+            context=context,
+            status=WAIT,
+            updated={"items": foreach, "foreach": {}},
+        )
         len_foreach: int = len(foreach)
         if event and event.is_set():
             raise StageCancelError(
@@ -2134,30 +2541,32 @@ class ForEachStage(BaseNestedStage):
         with ThreadPoolExecutor(self.concurrent, "stf") as executor:
             futures: list[Future] = [
                 executor.submit(
-                    self.execute_item,
+                    self._process_item,
                     index=i,
                     item=item,
                     params=params,
-                    result=result,
+                    run_id=run_id,
+                    context=context,
+                    parent_run_id=parent_run_id,
                     event=event,
                 )
                 for i, item in enumerate(foreach, start=0)
             ]
 
-            context: DictData = {}
+            errors: DictData = {}
             statuses: list[Status] = [WAIT] * len_foreach
             fail_fast: bool = False
 
             done, not_done = wait(futures, return_when=FIRST_EXCEPTION)
             if len(list(done)) != len(futures):
-                result.trace.warning(
+                trace.warning(
                     "[STAGE]: Set the event for stop pending for-each stage."
                 )
                 event.set()
                 for future in not_done:
                     future.cancel()
 
-                time.sleep(0.025)
+                time.sleep(0.01)  # Reduced from 0.025 for better responsiveness
                 nd: str = (
                     (
                         f", {len(not_done)} item"
@@ -2166,18 +2575,17 @@ class ForEachStage(BaseNestedStage):
                     if not_done
                     else ""
                 )
-                result.trace.debug(
-                    f"[STAGE]: ... Foreach-Stage set failed event{nd}"
-                )
+                trace.debug(f"[STAGE]: ... Foreach-Stage set failed event{nd}")
                 done: Iterator[Future] = as_completed(futures)
                 fail_fast = True
 
             for i, future in enumerate(done, start=0):
                 try:
+                    # NOTE: Ignore returned context because it already updated.
                     statuses[i], _ = future.result()
                 except StageError as e:
                     statuses[i] = get_status_from_error(e)
-                    self.mark_errors(context, e)
+                    self.mark_errors(errors, e)
                 except CancelledError:
                     pass
 
@@ -2188,7 +2596,13 @@ class ForEachStage(BaseNestedStage):
         if fail_fast and status == CANCEL:
             status = FAILED
 
-        return result.catch(status=status, context=context)
+        return Result(
+            run_id=run_id,
+            parent_run_id=parent_run_id,
+            status=status,
+            context=catch(context, status=status, updated=errors),
+            extras=self.extras,
+        )
 
 
 class UntilStage(BaseNestedStage):
@@ -2239,32 +2653,40 @@ class UntilStage(BaseNestedStage):
         alias="max-loop",
     )
 
-    def execute_loop(
+    def _process_loop(
         self,
         item: T,
         loop: int,
         params: DictData,
-        result: Result,
+        run_id: str,
+        context: DictData,
+        *,
+        parent_run_id: Optional[str] = None,
         event: Optional[Event] = None,
-    ) -> tuple[Status, Result, T]:
+    ) -> tuple[Status, DictData, T]:
         """Execute loop that will execute all nested-stage that was set in this
         stage with specific loop and item.
 
         :param item: (T) An item that want to execution.
         :param loop: (int) A number of loop.
         :param params: (DictData) A parameter data.
-        :param result: (Result) A Result instance for return context and status.
+        :param run_id: (str)
+        :param context: (DictData)
+        :param parent_run_id: (str | None)
         :param event: (Event) An Event manager instance that use to cancel this
             execution if it forces stopped by parent execution.
 
-        :rtype: tuple[Status, Result, T]
+        :rtype: tuple[Status, DictData, T]
         :return: Return a pair of Result and changed item.
         """
-        result.trace.debug(f"[STAGE]: Execute Loop: {loop} (Item {item!r})")
+        trace: Trace = get_trace(
+            run_id, parent_run_id=parent_run_id, extras=self.extras
+        )
+        trace.debug(f"[STAGE]: Execute Loop: {loop} (Item {item!r})")
 
         # NOTE: Create nested-context
-        context: DictData = copy.deepcopy(params)
-        context.update({"item": item, "loop": loop})
+        current_context: DictData = copy.deepcopy(params)
+        current_context.update({"item": item, "loop": loop})
         nestet_context: DictData = {"loop": loop, "item": item, "stages": {}}
 
         next_item: Optional[T] = None
@@ -2280,7 +2702,8 @@ class UntilStage(BaseNestedStage):
                     "Loop execution was canceled from the event before start "
                     "loop execution."
                 )
-                result.catch(
+                catch(
+                    context=context,
                     status=CANCEL,
                     until={
                         loop: {
@@ -2296,10 +2719,9 @@ class UntilStage(BaseNestedStage):
                 )
                 raise StageCancelError(error_msg, refs=loop)
 
-            rs: Result = stage.handler_execute(
-                params=context,
-                run_id=result.run_id,
-                parent_run_id=result.parent_run_id,
+            rs: Result = stage.execute(
+                params=current_context,
+                run_id=parent_run_id,
                 event=event,
             )
             stage.set_outputs(rs.context, to=nestet_context)
@@ -2307,7 +2729,7 @@ class UntilStage(BaseNestedStage):
             if "item" in (_output := stage.get_outputs(nestet_context)):
                 next_item = _output["item"]
 
-            stage.set_outputs(_output, to=context)
+            stage.set_outputs(_output, to=current_context)
 
             if rs.status == SKIP:
                 skips[i] = True
@@ -2318,7 +2740,8 @@ class UntilStage(BaseNestedStage):
                     f"Loop execution was break because its nested-stage, "
                     f"{stage.iden!r}, failed."
                 )
-                result.catch(
+                catch(
+                    context=context,
                     status=FAILED,
                     until={
                         loop: {
@@ -2339,7 +2762,8 @@ class UntilStage(BaseNestedStage):
                     "Loop execution was canceled from the event after "
                     "end loop execution."
                 )
-                result.catch(
+                catch(
+                    context=context,
                     status=CANCEL,
                     until={
                         loop: {
@@ -2358,7 +2782,8 @@ class UntilStage(BaseNestedStage):
         status: Status = SKIP if sum(skips) == total_stage else SUCCESS
         return (
             status,
-            result.catch(
+            catch(
+                context=context,
                 status=status,
                 until={
                     loop: {
@@ -2372,37 +2797,42 @@ class UntilStage(BaseNestedStage):
             next_item,
         )
 
-    def execute(
+    def process(
         self,
         params: DictData,
+        run_id: str,
+        context: DictData,
         *,
-        result: Optional[Result] = None,
+        parent_run_id: Optional[str] = None,
         event: Optional[Event] = None,
     ) -> Result:
         """Execute until loop with checking the until condition before release
         the next loop.
 
-        :param params: (DictData) A parameter data.
-        :param result: (Result) A Result instance for return context and status.
-        :param event: (Event) An Event manager instance that use to cancel this
-            execution if it forces stopped by parent execution.
-            (Default is None)
-
-        :rtype: Result
+        Args:
+            params: A parameter data that want to use in this
+                execution.
+            run_id: A running stage ID.
+            context: A context data.
+            parent_run_id: A parent running ID. (Default is None)
+            event: An event manager that use to track parent process
+                was not force stopped.
+
+        Returns:
+            Result: The execution result with status and context data.
         """
-        result: Result = result or Result(
-            run_id=gen_id(self.name + (self.id or ""), unique=True),
-            extras=self.extras,
+        trace: Trace = get_trace(
+            run_id, parent_run_id=parent_run_id, extras=self.extras
         )
         event: Event = event or Event()
-        result.trace.info(f"[STAGE]: Until: {self.until!r}")
+        trace.info(f"[STAGE]: Until: {self.until!r}")
         item: Union[str, int, bool] = pass_env(
             param2template(self.item, params, extras=self.extras)
         )
         loop: int = 1
         until_rs: bool = True
         exceed_loop: bool = False
-        result.catch(status=WAIT, context={"until": {}})
+        catch(context=context, status=WAIT, updated={"until": {}})
         statuses: list[Status] = []
         while until_rs and not (exceed_loop := (loop > self.max_loop)):
 
@@ -2411,18 +2841,20 @@ class UntilStage(BaseNestedStage):
                     "Execution was canceled from the event before start loop."
                 )
 
-            status, result, item = self.execute_loop(
+            status, context, item = self._process_loop(
                 item=item,
                 loop=loop,
                 params=params,
-                result=result,
+                run_id=run_id,
+                context=context,
+                parent_run_id=parent_run_id,
                 event=event,
             )
 
             loop += 1
             if item is None:
                 item: int = loop
-                result.trace.warning(
+                trace.warning(
                     f"[STAGE]: Return loop not set the item. It uses loop: "
                     f"{loop} by default."
                 )
@@ -2453,7 +2885,15 @@ class UntilStage(BaseNestedStage):
                 f"loop{'s' if self.max_loop > 1 else ''}."
             )
             raise StageError(error_msg)
-        return result.catch(status=validate_statuses(statuses))
+
+        st: Status = validate_statuses(statuses)
+        return Result(
+            run_id=run_id,
+            parent_run_id=parent_run_id,
+            status=st,
+            context=catch(context, status=st),
+            extras=self.extras,
+        )
 
 
 class Match(BaseModel):
@@ -2509,28 +2949,36 @@ class CaseStage(BaseNestedStage):
         alias="skip-not-match",
     )
 
-    def execute_case(
+    def _process_case(
         self,
         case: str,
         stages: list[Stage],
         params: DictData,
-        result: Result,
+        run_id: str,
+        context: DictData,
         *,
+        parent_run_id: Optional[str] = None,
         event: Optional[Event] = None,
-    ) -> Result:
+    ) -> tuple[Status, DictData]:
         """Execute case.
 
         :param case: (str) A case that want to execution.
         :param stages: (list[Stage]) A list of stage.
         :param params: (DictData) A parameter data.
-        :param result: (Result) A Result instance for return context and status.
+        :param run_id: (str)
+        :param context: (DictData)
+        :param parent_run_id: (str | None)
         :param event: (Event) An Event manager instance that use to cancel this
             execution if it forces stopped by parent execution.
 
-        :rtype: Result
+        :rtype: DictData
         """
-        context: DictData = copy.deepcopy(params)
-        context.update({"case": case})
+        trace: Trace = get_trace(
+            run_id, parent_run_id=parent_run_id, extras=self.extras
+        )
+        trace.debug(f"[STAGE]: Execute Case: {case!r}")
+        current_context: DictData = copy.deepcopy(params)
+        current_context.update({"case": case})
         output: DictData = {"case": case, "stages": {}}
         for stage in stages:
 
@@ -2542,69 +2990,77 @@ class CaseStage(BaseNestedStage):
                     "Case-Stage was canceled from event that had set before "
                     "stage case execution."
                 )
-                return result.catch(
+                return CANCEL, catch(
+                    context=context,
                     status=CANCEL,
-                    context={
+                    updated={
                         "case": case,
                         "stages": filter_func(output.pop("stages", {})),
                         "errors": StageError(error_msg).to_dict(),
                     },
                 )
 
-            rs: Result = stage.handler_execute(
-                params=context,
-                run_id=result.run_id,
-                parent_run_id=result.parent_run_id,
+            rs: Result = stage.execute(
+                params=current_context,
+                run_id=parent_run_id,
                 event=event,
             )
             stage.set_outputs(rs.context, to=output)
-            stage.set_outputs(stage.get_outputs(output), to=context)
+            stage.set_outputs(stage.get_outputs(output), to=current_context)
 
             if rs.status == FAILED:
                 error_msg: str = (
                     f"Case-Stage was break because it has a sub stage, "
                     f"{stage.iden}, failed without raise error."
                 )
-                return result.catch(
+                return FAILED, catch(
+                    context=context,
                     status=FAILED,
-                    context={
+                    updated={
                         "case": case,
                         "stages": filter_func(output.pop("stages", {})),
                         "errors": StageError(error_msg).to_dict(),
                     },
                 )
-        return result.catch(
+        return SUCCESS, catch(
+            context=context,
             status=SUCCESS,
-            context={
+            updated={
                 "case": case,
                 "stages": filter_func(output.pop("stages", {})),
             },
         )
 
-    def execute(
+    def process(
         self,
         params: DictData,
+        run_id: str,
+        context: DictData,
         *,
-        result: Optional[Result] = None,
+        parent_run_id: Optional[str] = None,
         event: Optional[Event] = None,
     ) -> Result:
         """Execute case-match condition that pass to the case field.
 
-        :param params: (DictData) A parameter data.
-        :param result: (Result) A Result instance for return context and status.
-        :param event: (Event) An Event manager instance that use to cancel this
-            execution if it forces stopped by parent execution.
-
-        :rtype: Result
+        Args:
+            params: A parameter data that want to use in this
+                execution.
+            run_id: A running stage ID.
+            context: A context data.
+            parent_run_id: A parent running ID. (Default is None)
+            event: An event manager that use to track parent process
+                was not force stopped.
+
+        Returns:
+            Result: The execution result with status and context data.
         """
-        result: Result = result or Result(
-            run_id=gen_id(self.name + (self.id or ""), unique=True),
-            extras=self.extras,
+        trace: Trace = get_trace(
+            run_id, parent_run_id=parent_run_id, extras=self.extras
         )
 
         _case: StrOrNone = param2template(self.case, params, extras=self.extras)
 
-        result.trace.info(f"[STAGE]: Case: {_case!r}.")
+        trace.info(f"[STAGE]: Case: {_case!r}.")
         _else: Optional[Match] = None
         stages: Optional[list[Stage]] = None
         for match in self.match:
@@ -2636,9 +3092,21 @@ class CaseStage(BaseNestedStage):
                 "Execution was canceled from the event before start "
                 "case execution."
             )
-
-        return self.execute_case(
-            case=_case, stages=stages, params=params, result=result, event=event
+        status, context = self._process_case(
+            case=_case,
+            stages=stages,
+            params=params,
+            run_id=run_id,
+            context=context,
+            parent_run_id=parent_run_id,
+            event=event,
+        )
+        return Result(
+            run_id=run_id,
+            parent_run_id=parent_run_id,
+            status=status,
+            context=catch(context, status=status),
+            extras=self.extras,
         )
 
 
@@ -2661,53 +3129,65 @@ class RaiseStage(BaseAsyncStage):
         alias="raise",
     )
 
-    def execute(
+    def process(
         self,
         params: DictData,
+        run_id: str,
+        context: DictData,
         *,
-        result: Optional[Result] = None,
+        parent_run_id: Optional[str] = None,
         event: Optional[Event] = None,
     ) -> Result:
         """Raise the StageError object with the message field execution.
 
-        :param params: (DictData) A parameter data.
-        :param result: (Result) A Result instance for return context and status.
-        :param event: (Event) An Event manager instance that use to cancel this
-            execution if it forces stopped by parent execution.
+        Args:
+            params: A parameter data that want to use in this
+                execution.
+            run_id: A running stage ID.
+            context: A context data.
+            parent_run_id: A parent running ID. (Default is None)
+            event: An event manager that use to track parent process
+                was not force stopped.
+
+        Returns:
+            Result: The execution result with status and context data.
         """
-        result: Result = result or Result(
-            run_id=gen_id(self.name + (self.id or ""), unique=True),
-            extras=self.extras,
+        trace: Trace = get_trace(
+            run_id, parent_run_id=parent_run_id, extras=self.extras
         )
         message: str = param2template(self.message, params, extras=self.extras)
-        result.trace.info(f"[STAGE]: Message: ( {message} )")
+        trace.info(f"[STAGE]: Message: ( {message} )")
         raise StageError(message)
 
-    async def axecute(
+    async def async_process(
         self,
         params: DictData,
+        run_id: str,
+        context: DictData,
         *,
-        result: Optional[Result] = None,
+        parent_run_id: Optional[str] = None,
         event: Optional[Event] = None,
     ) -> Result:
         """Async execution method for this Empty stage that only logging out to
         stdout.
 
-        :param params: (DictData) A context data that want to add output result.
-            But this stage does not pass any output.
-        :param result: (Result) A result object for keeping context and status
-            data.
-        :param event: (Event) An event manager that use to track parent execute
-            was not force stopped.
-
-        :rtype: Result
+        Args:
+            params: A parameter data that want to use in this
+                execution.
+            run_id: A running stage ID.
+            context: A context data.
+            parent_run_id: A parent running ID. (Default is None)
+            event: An event manager that use to track parent process
+                was not force stopped.
+
+        Returns:
+            Result: The execution result with status and context data.
         """
-        result: Result = result or Result(
-            run_id=gen_id(self.name + (self.id or ""), unique=True),
-            extras=self.extras,
+        trace: Trace = get_trace(
+            run_id, parent_run_id=parent_run_id, extras=self.extras
         )
         message: str = param2template(self.message, params, extras=self.extras)
-        await result.trace.ainfo(f"[STAGE]: Execute Raise-Stage: ( {message} )")
+        await trace.ainfo(f"[STAGE]: Execute Raise-Stage: ( {message} )")
         raise StageError(message)
 
 
@@ -2755,20 +3235,25 @@ class DockerStage(BaseStage):  # pragma: no cov
         ),
     )
 
-    def execute_task(
+    def _process_task(
         self,
         params: DictData,
-        result: Result,
+        run_id: str,
+        context: DictData,
+        *,
+        parent_run_id: Optional[str] = None,
         event: Optional[Event] = None,
-    ) -> Result:
+    ) -> DictData:
         """Execute Docker container task.
 
         :param params: (DictData) A parameter data.
-        :param result: (Result) A Result instance for return context and status.
+        :param run_id: (str)
+        :param context: (DictData)
+        :param parent_run_id: (str | None)
         :param event: (Event) An Event manager instance that use to cancel this
             execution if it forces stopped by parent execution.
 
-        :rtype: Result
+        :rtype: DictData
         """
         try:
             from docker import DockerClient
@@ -2779,6 +3264,9 @@ class DockerStage(BaseStage):  # pragma: no cov
                 "by `pip install docker` first."
             ) from None
 
+        trace: Trace = get_trace(
+            run_id, parent_run_id=parent_run_id, extras=self.extras
+        )
         client = DockerClient(
             base_url="unix://var/run/docker.sock", version="auto"
         )
@@ -2793,16 +3281,17 @@ class DockerStage(BaseStage):  # pragma: no cov
             decode=True,
         )
         for line in resp:
-            result.trace.info(f"[STAGE]: ... {line}")
+            trace.info(f"[STAGE]: ... {line}")
 
         if event and event.is_set():
             error_msg: str = (
                 "Docker-Stage was canceled from event that had set before "
                 "run the Docker container."
             )
-            return result.catch(
+            return catch(
+                context=context,
                 status=CANCEL,
-                context={"errors": StageError(error_msg).to_dict()},
+                updated={"errors": StageError(error_msg).to_dict()},
             )
 
         unique_image_name: str = f"{self.image}_{datetime.now():%Y%m%d%H%M%S%f}"
@@ -2813,7 +3302,7 @@ class DockerStage(BaseStage):  # pragma: no cov
             volumes=pass_env(
                 {
                     Path.cwd()
-                    / f".docker.{result.run_id}.logs": {
+                    / f".docker.{run_id}.logs": {
                         "bind": "/logs",
                         "mode": "rw",
                     },
@@ -2829,7 +3318,7 @@ class DockerStage(BaseStage):  # pragma: no cov
         )
 
         for line in container.logs(stream=True, timestamps=True):
-            result.trace.info(f"[STAGE]: ... {line.strip().decode()}")
+            trace.info(f"[STAGE]: ... {line.strip().decode()}")
 
         # NOTE: This code copy from the docker package.
         exit_status: int = container.wait()["StatusCode"]
@@ -2843,36 +3332,42 @@ class DockerStage(BaseStage):  # pragma: no cov
                 f"{self.image}:{self.tag}",
                 out.decode("utf-8"),
             )
-        output_file: Path = Path(f".docker.{result.run_id}.logs/outputs.json")
+        output_file: Path = Path(f".docker.{run_id}.logs/outputs.json")
         if not output_file.exists():
-            return result.catch(status=SUCCESS)
-
-        with output_file.open(mode="rt") as f:
-            data = json.load(f)
-        return result.catch(status=SUCCESS, context=data)
+            return catch(context=context, status=SUCCESS)
+        return catch(
+            context=context,
+            status=SUCCESS,
+            updated=json.loads(output_file.read_text()),
+        )
 
-    def execute(
+    def process(
         self,
         params: DictData,
+        run_id: str,
+        context: DictData,
         *,
-        result: Optional[Result] = None,
+        parent_run_id: Optional[str] = None,
         event: Optional[Event] = None,
     ) -> Result:
         """Execute the Docker image via Python API.
 
-        :param params: (DictData) A parameter data.
-        :param result: (Result) A Result instance for return context and status.
-        :param event: (Event) An Event manager instance that use to cancel this
-            execution if it forces stopped by parent execution.
-
-        :rtype: Result
+        Args:
+            params: A parameter data that want to use in this
+                execution.
+            run_id: A running stage ID.
+            context: A context data.
+            parent_run_id: A parent running ID. (Default is None)
+            event: An event manager that use to track parent process
+                was not force stopped.
+
+        Returns:
+            Result: The execution result with status and context data.
         """
-        result: Result = result or Result(
-            run_id=gen_id(self.name + (self.id or ""), unique=True),
-            extras=self.extras,
+        trace: Trace = get_trace(
+            run_id, parent_run_id=parent_run_id, extras=self.extras
         )
-
-        result.trace.info(f"[STAGE]: Docker: {self.image}:{self.tag}")
+        trace.info(f"[STAGE]: Docker: {self.image}:{self.tag}")
         raise NotImplementedError("Docker Stage does not implement yet.")
 
 
@@ -2947,11 +3442,18 @@ class VirtualPyStage(PyStage):  # pragma: no cov
         # Note: Remove .py file that use to run Python.
         Path(f"./{f_name}").unlink()
 
-    def execute(
+    @staticmethod
+    def prepare_std(value: str) -> Optional[str]:
+        """Prepare returned standard string from subprocess."""
+        return None if (out := value.strip("\n")) == "" else out
+
+    def process(
         self,
         params: DictData,
+        run_id: str,
+        context: DictData,
         *,
-        result: Optional[Result] = None,
+        parent_run_id: Optional[str] = None,
         event: Optional[Event] = None,
     ) -> Result:
         """Execute the Python statement via Python virtual environment.
@@ -2960,25 +3462,29 @@ class VirtualPyStage(PyStage):  # pragma: no cov
             - Create python file with the `uv` syntax.
             - Execution python file with `uv run` via Python subprocess module.
 
-        :param params: (DictData) A parameter data.
-        :param result: (Result) A Result instance for return context and status.
-        :param event: (Event) An Event manager instance that use to cancel this
-            execution if it forces stopped by parent execution.
-
-        :rtype: Result
+        Args:
+            params: A parameter data that want to use in this
+                execution.
+            run_id: A running stage ID.
+            context: A context data.
+            parent_run_id: A parent running ID. (Default is None)
+            event: An event manager that use to track parent process
+                was not force stopped.
+
+        Returns:
+            Result: The execution result with status and context data.
         """
-        result: Result = result or Result(
-            run_id=gen_id(self.name + (self.id or ""), unique=True),
-            extras=self.extras,
+        trace: Trace = get_trace(
+            run_id, parent_run_id=parent_run_id, extras=self.extras
         )
         run: str = param2template(dedent(self.run), params, extras=self.extras)
         with self.create_py_file(
             py=run,
             values=param2template(self.vars, params, extras=self.extras),
             deps=param2template(self.deps, params, extras=self.extras),
-            run_id=result.run_id,
+            run_id=run_id,
         ) as py:
-            result.trace.debug(f"[STAGE]: Create `{py}` file.")
+            trace.debug(f"[STAGE]: Create `{py}` file.")
             rs: CompletedProcess = subprocess.run(
                 ["python", "-m", "uv", "run", py, "--no-cache"],
                 # ["uv", "run", "--python", "3.9", py],
@@ -2998,13 +3504,20 @@ class VirtualPyStage(PyStage):  # pragma: no cov
                 f"Subprocess: {e}\nRunning Statement:\n---\n"
                 f"```python\n{run}\n```"
             )
-        return result.catch(
+        return Result(
+            run_id=run_id,
+            parent_run_id=parent_run_id,
             status=SUCCESS,
-            context={
-                "return_code": rs.returncode,
-                "stdout": None if (out := rs.stdout.strip("\n")) == "" else out,
-                "stderr": None if (out := rs.stderr.strip("\n")) == "" else out,
-            },
+            context=catch(
+                context=context,
+                status=SUCCESS,
+                updated={
+                    "return_code": rs.returncode,
+                    "stdout": self.prepare_std(rs.stdout),
+                    "stderr": self.prepare_std(rs.stderr),
+                },
+            ),
+            extras=self.extras,
         )