diff --git a/src/platform/plugins/shared/workflows_management/common/translations.ts b/src/platform/plugins/shared/workflows_management/common/translations.ts
index 09c83f62a0526..342ec29790f83 100644
--- a/src/platform/plugins/shared/workflows_management/common/translations.ts
+++ b/src/platform/plugins/shared/workflows_management/common/translations.ts
@@ -23,30 +23,6 @@ export const SEARCH_PLACEHOLDER = i18n.translate(
   }
 );
 
-export const MANUAL_TRIGGERS_DESCRIPTIONS: Record<string, string> = {
-  manual: i18n.translate(
-    'plugins.workflowsManagement.workflowsExecution.manualTriggerDescription',
-    {
-      defaultMessage:
-        'Provide custom JSON data manually for testing. Ideal for simulating specific scenarios or debugging edge cases.',
-    }
-  ),
-  index: i18n.translate('plugins.workflowsManagement.workflowsExecution.indexTriggerDescription', {
-    defaultMessage:
-      'Choose a document directly from an index to use as the test input. This is helpful for verifying workflows against real indexed data.',
-  }),
-  alert: i18n.translate('plugins.workflowsManagement.workflowsExecution.alertTriggerDescription', {
-    defaultMessage:
-      'Choose an existing alert directly from an index to use as the test input. This is helpful for verifying workflows against real alerts data.',
-  }),
-  scheduled: i18n.translate(
-    'plugins.workflowsManagement.workflowsExecution.scheduledTriggerDescription',
-    {
-      defaultMessage: 'Select a schedule to trigger workflow',
-    }
-  ),
-};
-
 export const TRIGGERS_LIST_TITLE = i18n.translate(
   'plugins.workflowsManagement.workflowsList.triggersListTitle',
   {
diff --git a/src/platform/plugins/shared/workflows_management/public/common/lib/telemetry/events/workflows/execution/index.ts b/src/platform/plugins/shared/workflows_management/public/common/lib/telemetry/events/workflows/execution/index.ts
index 8dc5ea7a782a5..b8d0d79ce6dc7 100644
--- a/src/platform/plugins/shared/workflows_management/public/common/lib/telemetry/events/workflows/execution/index.ts
+++ b/src/platform/plugins/shared/workflows_management/public/common/lib/telemetry/events/workflows/execution/index.ts
@@ -100,7 +100,8 @@ const workflowTestRunInitiatedSchema: RootSchema<ReportWorkflowTestRunInitiatedA
   triggerTab: {
     type: 'keyword',
     _meta: {
-      description: 'The trigger tab selected in the Test Workflow modal: manual, alert, or index',
+      description:
+        'The trigger tab selected in the Test Workflow modal: manual, alert, index, or historical',
       optional: true,
     },
   },
diff --git a/src/platform/plugins/shared/workflows_management/public/common/lib/telemetry/events/workflows/execution/types.ts b/src/platform/plugins/shared/workflows_management/public/common/lib/telemetry/events/workflows/execution/types.ts
index 89e6bed2634eb..a16a84d03b454 100644
--- a/src/platform/plugins/shared/workflows_management/public/common/lib/telemetry/events/workflows/execution/types.ts
+++ b/src/platform/plugins/shared/workflows_management/public/common/lib/telemetry/events/workflows/execution/types.ts
@@ -7,6 +7,7 @@
  * License v3.0 only", or the "Server Side Public License, v 1".
  */
 
+import type { WorkflowTriggerTab } from '../../../../../../features/run_workflow/ui/types';
 import type { BaseResultActionParams, WorkflowEditorType } from '../types';
 
 export enum WorkflowExecutionEventTypes {
@@ -32,13 +33,6 @@ export enum WorkflowExecutionEventTypes {
   WorkflowRunCancelled = 'workflows_workflow_run_cancelled',
 }
 
-export type WorkflowTriggerType = 'manual' | 'alert' | 'scheduled';
-
-/**
- * Trigger tab types available in the Test Workflow modal
- */
-export type WorkflowTriggerTab = 'manual' | 'alert' | 'index';
-
 /**
  * Parameters for workflow test run initiation telemetry.
  */
@@ -61,7 +55,7 @@ export interface ReportWorkflowTestRunInitiatedActionParams extends BaseResultAc
    */
   editorType?: WorkflowEditorType;
   /**
-   * The trigger tab selected in the Test Workflow modal: 'manual', 'alert', or 'index'
+   * The trigger tab selected in the Test Workflow modal
    */
   triggerTab?: WorkflowTriggerTab;
 }
diff --git a/src/platform/plugins/shared/workflows_management/public/common/service/telemetry.ts b/src/platform/plugins/shared/workflows_management/public/common/service/telemetry.ts
index 55475e023bc45..077a1dc9dd15f 100644
--- a/src/platform/plugins/shared/workflows_management/public/common/service/telemetry.ts
+++ b/src/platform/plugins/shared/workflows_management/public/common/service/telemetry.ts
@@ -8,6 +8,7 @@
  */
 
 import type { WorkflowYaml } from '@kbn/workflows/spec/schema';
+import type { WorkflowTriggerTab } from '../../features/run_workflow/ui/types';
 import type { YamlValidationResult } from '../../features/validate_workflow_yaml/model/types';
 import {
   workflowEventNames,
@@ -16,7 +17,6 @@ import {
   WorkflowUIEventTypes,
   WorkflowValidationEventTypes,
 } from '../lib/telemetry/events/workflows';
-import type { WorkflowTriggerTab } from '../lib/telemetry/events/workflows/execution/types';
 import type {
   WorkflowEditorType,
   WorkflowTelemetryOrigin,
diff --git a/src/platform/plugins/shared/workflows_management/public/entities/workflows/model/use_workflow_actions.ts b/src/platform/plugins/shared/workflows_management/public/entities/workflows/model/use_workflow_actions.ts
index 4423feff09727..e590dd08424b8 100644
--- a/src/platform/plugins/shared/workflows_management/public/entities/workflows/model/use_workflow_actions.ts
+++ b/src/platform/plugins/shared/workflows_management/public/entities/workflows/model/use_workflow_actions.ts
@@ -16,6 +16,7 @@ import type {
   WorkflowDetailDto,
   WorkflowListDto,
 } from '@kbn/workflows';
+import type { WorkflowTriggerTab } from '../../../features/run_workflow/ui/types';
 import { useKibana } from '../../../hooks/use_kibana';
 import { useTelemetry } from '../../../hooks/use_telemetry';
 
@@ -223,7 +224,7 @@ export function useWorkflowActions() {
   const runWorkflow = useMutation<
     RunWorkflowResponseDto,
     HttpError,
-    RunWorkflowCommand & { id: string; triggerTab?: 'manual' | 'alert' | 'index' }
+    RunWorkflowCommand & { id: string; triggerTab?: WorkflowTriggerTab }
   >({
     mutationKey: ['POST', 'workflows', 'id', 'run'],
     mutationFn: ({ id, inputs }) => {
diff --git a/src/platform/plugins/shared/workflows_management/public/entities/workflows/model/use_workflow_execution.ts b/src/platform/plugins/shared/workflows_management/public/entities/workflows/model/use_workflow_execution.ts
new file mode 100644
index 0000000000000..a2901db8a11f1
--- /dev/null
+++ b/src/platform/plugins/shared/workflows_management/public/entities/workflows/model/use_workflow_execution.ts
@@ -0,0 +1,33 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the "Elastic License
+ * 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side
+ * Public License v 1"; you may not use this file except in compliance with, at
+ * your election, the "Elastic License 2.0", the "GNU Affero General Public
+ * License v3.0 only", or the "Server Side Public License, v 1".
+ */
+
+import { useQuery } from '@kbn/react-query';
+import type { WorkflowExecutionDto } from '@kbn/workflows';
+import { useKibana } from '../../../hooks/use_kibana';
+
+interface UseWorkflowExecutionParams {
+  executionId: string | null;
+  enabled?: boolean;
+}
+
+export function useWorkflowExecution({ executionId, enabled = true }: UseWorkflowExecutionParams) {
+  const { http } = useKibana().services;
+
+  return useQuery<WorkflowExecutionDto | null>({
+    queryKey: ['workflowExecution', executionId],
+    queryFn: async () => {
+      if (!executionId) return null;
+      const response = await http.get<WorkflowExecutionDto>(
+        `/api/workflowExecutions/${executionId}`
+      );
+      return response;
+    },
+    enabled: enabled && executionId !== null,
+  });
+}
diff --git a/src/platform/plugins/shared/workflows_management/public/entities/workflows/store/workflow_detail/selectors.ts b/src/platform/plugins/shared/workflows_management/public/entities/workflows/store/workflow_detail/selectors.ts
index 47c00dc7e93b3..f980e3c86d356 100644
--- a/src/platform/plugins/shared/workflows_management/public/entities/workflows/store/workflow_detail/selectors.ts
+++ b/src/platform/plugins/shared/workflows_management/public/entities/workflows/store/workflow_detail/selectors.ts
@@ -52,8 +52,8 @@ export const selectWorkflowDefinition = createSelector(
 );
 
 // Only checks if the current workflow yaml can be parsed, does not check the schema, only the yaml syntax
-export const selectIsYamlSyntaxValid = createSelector(selectYamlComputed, (computed): boolean =>
-  Boolean(computed?.workflowDefinition)
+export const selectIsYamlSyntaxValid = createSelector(selectYamlDocument, (yamlDoc): boolean =>
+  Boolean(yamlDoc && yamlDoc.errors.length === 0)
 );
 
 // Checks whether validation errors (from strict schema + custom validations) are present
@@ -74,6 +74,11 @@ export const selectIsTestModalOpen = createSelector(
   (detail) => detail.isTestModalOpen
 );
 
+export const selectReplayExecutionId = createSelector(
+  selectDetail,
+  (detail) => detail.replayExecutionId
+);
+
 export const selectIsSavingYaml = createSelector(
   selectDetail,
   (detail) => detail.loading.isSavingYaml
diff --git a/src/platform/plugins/shared/workflows_management/public/entities/workflows/store/workflow_detail/slice.ts b/src/platform/plugins/shared/workflows_management/public/entities/workflows/store/workflow_detail/slice.ts
index 88aad8972d9e8..09d21f24474ff 100644
--- a/src/platform/plugins/shared/workflows_management/public/entities/workflows/store/workflow_detail/slice.ts
+++ b/src/platform/plugins/shared/workflows_management/public/entities/workflows/store/workflow_detail/slice.ts
@@ -30,6 +30,7 @@ const initialState: WorkflowDetailState = {
   focusedStepId: undefined,
   highlightedStepId: undefined,
   isTestModalOpen: false,
+  replayExecutionId: null,
   loading: initialLoadingState,
   hasYamlSchemaValidationErrors: false,
   connectorFlyout: {
@@ -76,6 +77,9 @@ const workflowDetailSlice = createSlice({
     setIsTestModalOpen: (state, action: { payload: boolean }) => {
       state.isTestModalOpen = action.payload;
     },
+    setReplayExecutionId: (state, action: { payload: string | null }) => {
+      state.replayExecutionId = action.payload;
+    },
     setConnectors: (state, action: { payload: WorkflowDetailState['connectors'] }) => {
       state.connectors = action.payload;
     },
@@ -152,6 +156,7 @@ export const {
   setCursorPosition,
   setHighlightedStepId,
   setIsTestModalOpen,
+  setReplayExecutionId,
   setConnectors,
   setExecution,
   clearExecution,
diff --git a/src/platform/plugins/shared/workflows_management/public/entities/workflows/store/workflow_detail/thunks/test_workflow_thunk.ts b/src/platform/plugins/shared/workflows_management/public/entities/workflows/store/workflow_detail/thunks/test_workflow_thunk.ts
index 357d05b7aa6ea..b3e10224a44e2 100644
--- a/src/platform/plugins/shared/workflows_management/public/entities/workflows/store/workflow_detail/thunks/test_workflow_thunk.ts
+++ b/src/platform/plugins/shared/workflows_management/public/entities/workflows/store/workflow_detail/thunks/test_workflow_thunk.ts
@@ -10,13 +10,14 @@
 import { createAsyncThunk } from '@reduxjs/toolkit';
 import { i18n } from '@kbn/i18n';
 import { WorkflowsBaseTelemetry } from '../../../../../common/service/telemetry';
+import type { WorkflowTriggerTab } from '../../../../../features/run_workflow/ui/types';
 import type { WorkflowsServices } from '../../../../../types';
 import type { RootState } from '../../types';
 import { selectWorkflow, selectYamlString } from '../selectors';
 
 export interface TestWorkflowParams {
   inputs: Record<string, unknown>;
-  triggerTab?: 'manual' | 'alert' | 'index';
+  triggerTab?: WorkflowTriggerTab;
 }
 
 export interface TestWorkflowResponse {
diff --git a/src/platform/plugins/shared/workflows_management/public/entities/workflows/store/workflow_detail/types.ts b/src/platform/plugins/shared/workflows_management/public/entities/workflows/store/workflow_detail/types.ts
index 7312ad9c68666..2a977b8c26caa 100644
--- a/src/platform/plugins/shared/workflows_management/public/entities/workflows/store/workflow_detail/types.ts
+++ b/src/platform/plugins/shared/workflows_management/public/entities/workflows/store/workflow_detail/types.ts
@@ -43,6 +43,8 @@ export interface WorkflowDetailState {
   highlightedStepId?: string;
   /** The modal to test the workflow is open */
   isTestModalOpen: boolean;
+  /** When set, open test modal in "From historical" mode with this execution pre-selected */
+  replayExecutionId: string | null;
   /** The connectors data */
   connectors?: ConnectorsResponse;
   /** The schema for the workflow, depends on the connectors available */
diff --git a/src/platform/plugins/shared/workflows_management/public/features/run_workflow/ui/constants.ts b/src/platform/plugins/shared/workflows_management/public/features/run_workflow/ui/constants.ts
new file mode 100644
index 0000000000000..6c339bc2dc497
--- /dev/null
+++ b/src/platform/plugins/shared/workflows_management/public/features/run_workflow/ui/constants.ts
@@ -0,0 +1,10 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the "Elastic License
+ * 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side
+ * Public License v 1"; you may not use this file except in compliance with, at
+ * your election, the "Elastic License 2.0", the "GNU Affero General Public
+ * License v3.0 only", or the "Server Side Public License, v 1".
+ */
+
+export const ENABLED_TRIGGER_TABS = ['alert', 'index', 'manual', 'historical'] as const;
diff --git a/src/platform/plugins/shared/workflows_management/public/features/run_workflow/ui/translations.ts b/src/platform/plugins/shared/workflows_management/public/features/run_workflow/ui/translations.ts
new file mode 100644
index 0000000000000..bee938aa6b27e
--- /dev/null
+++ b/src/platform/plugins/shared/workflows_management/public/features/run_workflow/ui/translations.ts
@@ -0,0 +1,46 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the "Elastic License
+ * 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side
+ * Public License v 1"; you may not use this file except in compliance with, at
+ * your election, the "Elastic License 2.0", the "GNU Affero General Public
+ * License v3.0 only", or the "Server Side Public License, v 1".
+ */
+
+import { i18n } from '@kbn/i18n';
+import type { WorkflowTriggerTab } from './types';
+
+export const TRIGGER_TABS_LABELS: Record<WorkflowTriggerTab, string> = {
+  alert: i18n.translate('plugins.workflowsManagement.workflowsExecution.alertTriggerLabel', {
+    defaultMessage: 'Alert',
+  }),
+  index: i18n.translate('plugins.workflowsManagement.workflowsExecution.indexTriggerLabel', {
+    defaultMessage: 'Document',
+  }),
+  manual: i18n.translate('plugins.workflowsManagement.workflowsExecution.manualTriggerLabel', {
+    defaultMessage: 'Manual',
+  }),
+  historical: i18n.translate(
+    'plugins.workflowsManagement.workflowsExecution.historicalTriggerLabel',
+    { defaultMessage: 'Historical' }
+  ),
+};
+
+export const TRIGGER_TABS_DESCRIPTIONS: Record<WorkflowTriggerTab, string> = {
+  manual: i18n.translate(
+    'plugins.workflowsManagement.workflowsExecution.manualTriggerDescription',
+    {
+      defaultMessage: 'Provide custom JSON data manually.',
+    }
+  ),
+  index: i18n.translate('plugins.workflowsManagement.workflowsExecution.indexTriggerDescription', {
+    defaultMessage: 'Choose a document from Elasticsearch.',
+  }),
+  alert: i18n.translate('plugins.workflowsManagement.workflowsExecution.alertTriggerDescription', {
+    defaultMessage: 'Choose an existing alert directly.',
+  }),
+  historical: i18n.translate(
+    'plugins.workflowsManagement.workflowsExecution.historicalTriggerDescription',
+    { defaultMessage: 'Reuse input data from previous executions.' }
+  ),
+};
diff --git a/src/platform/plugins/shared/workflows_management/public/features/run_workflow/ui/types.ts b/src/platform/plugins/shared/workflows_management/public/features/run_workflow/ui/types.ts
new file mode 100644
index 0000000000000..35c1ea01709e3
--- /dev/null
+++ b/src/platform/plugins/shared/workflows_management/public/features/run_workflow/ui/types.ts
@@ -0,0 +1,12 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the "Elastic License
+ * 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side
+ * Public License v 1"; you may not use this file except in compliance with, at
+ * your election, the "Elastic License 2.0", the "GNU Affero General Public
+ * License v3.0 only", or the "Server Side Public License, v 1".
+ */
+
+import type { ENABLED_TRIGGER_TABS } from './constants';
+
+export type WorkflowTriggerTab = (typeof ENABLED_TRIGGER_TABS)[number];
diff --git a/src/platform/plugins/shared/workflows_management/public/features/run_workflow/ui/workflow_execute_event_form.tsx b/src/platform/plugins/shared/workflows_management/public/features/run_workflow/ui/workflow_execute_event_form.tsx
index 23255a7f6a23b..133e3fe239af9 100644
--- a/src/platform/plugins/shared/workflows_management/public/features/run_workflow/ui/workflow_execute_event_form.tsx
+++ b/src/platform/plugins/shared/workflows_management/public/features/run_workflow/ui/workflow_execute_event_form.tsx
@@ -15,6 +15,7 @@ import {
   EuiFlexGroup,
   EuiFlexItem,
   EuiLoadingSpinner,
+  EuiPanel,
   EuiSpacer,
   EuiText,
 } from '@elastic/eui';
@@ -325,29 +326,31 @@ export const WorkflowExecuteEventForm = ({
     <EuiFlexGroup direction="column" gutterSize="s">
       <EuiSpacer size="s" />
       <EuiFlexItem>
-        <AlertsSearchBar
-          appName="workflow_management"
-          showDatePicker
-          onQueryChange={handleQueryChange}
-          onQuerySubmit={handleQuerySubmit}
-          onFiltersUpdated={handleFiltersUpdated}
-          query={query}
-          filters={filters}
-          rangeFrom={timeRange.from}
-          rangeTo={timeRange.to}
-          showFilterBar={false}
-          showSubmitButton={true}
-          placeholder={i18n.translate('workflows.workflowExecuteEventForm.searchPlaceholder', {
-            defaultMessage:
-              'Filter your data using KQL syntax (e.g., rule.name:test or kibana.alert.rule.name:test)',
-          })}
-          ruleTypeIds={[]}
-          http={http}
-          toasts={notifications.toasts}
-          unifiedSearchBar={unifiedSearch.ui.SearchBar}
-          dataService={dataService}
-          fetchUnifiedAlertsFields={true}
-        />
+        <EuiPanel paddingSize="s" hasBorder={false} hasShadow={false} color="transparent">
+          <AlertsSearchBar
+            appName="workflow_management"
+            showDatePicker
+            onQueryChange={handleQueryChange}
+            onQuerySubmit={handleQuerySubmit}
+            onFiltersUpdated={handleFiltersUpdated}
+            query={query}
+            filters={filters}
+            rangeFrom={timeRange.from}
+            rangeTo={timeRange.to}
+            showFilterBar={false}
+            showSubmitButton={true}
+            placeholder={i18n.translate('workflows.workflowExecuteEventForm.searchPlaceholder', {
+              defaultMessage:
+                'Filter your data using KQL syntax (e.g., rule.name:test or kibana.alert.rule.name:test)',
+            })}
+            ruleTypeIds={[]}
+            http={http}
+            toasts={notifications.toasts}
+            unifiedSearchBar={unifiedSearch.ui.SearchBar}
+            dataService={dataService}
+            fetchUnifiedAlertsFields={true}
+          />
+        </EuiPanel>
       </EuiFlexItem>
       <EuiFlexItem>
         {alertsLoading ? (
diff --git a/src/platform/plugins/shared/workflows_management/public/features/run_workflow/ui/workflow_execute_historical_form.test.tsx b/src/platform/plugins/shared/workflows_management/public/features/run_workflow/ui/workflow_execute_historical_form.test.tsx
new file mode 100644
index 0000000000000..d9449ca7e4c87
--- /dev/null
+++ b/src/platform/plugins/shared/workflows_management/public/features/run_workflow/ui/workflow_execute_historical_form.test.tsx
@@ -0,0 +1,354 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the "Elastic License
+ * 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side
+ * Public License v 1"; you may not use this file except in compliance with, at
+ * your election, the "Elastic License 2.0", the "GNU Affero General Public
+ * License v3.0 only", or the "Server Side Public License, v 1".
+ */
+
+import { fireEvent, render, screen } from '@testing-library/react';
+import React from 'react';
+import { I18nProvider } from '@kbn/i18n-react';
+import { ExecutionStatus } from '@kbn/workflows';
+import {
+  NOT_READY_SENTINEL,
+  WorkflowExecuteHistoricalForm,
+} from './workflow_execute_historical_form';
+
+const mockUseWorkflowExecution = jest.fn();
+jest.mock('../../../entities/workflows/model/use_workflow_execution', () => ({
+  useWorkflowExecution: (...args: any[]) => mockUseWorkflowExecution(...args),
+}));
+
+const mockUseWorkflowExecutions = jest.fn();
+jest.mock('../../../entities/workflows/model/use_workflow_executions', () => ({
+  useWorkflowExecutions: (...args: any[]) => mockUseWorkflowExecutions(...args),
+}));
+
+jest.mock('../../../shared/ui/use_formatted_date', () => ({
+  useGetFormattedDateTime: () => (date: Date) => date.toISOString(),
+}));
+
+jest.mock('@kbn/code-editor', () => ({
+  CodeEditor: ({
+    value,
+    onChange,
+    dataTestSubj,
+  }: {
+    value: string;
+    onChange: (v: string) => void;
+    dataTestSubj: string;
+  }) => (
+    <textarea
+      data-test-subj={dataTestSubj}
+      value={value}
+      onChange={(e) => onChange(e.target.value)}
+    />
+  ),
+}));
+
+const renderWithProviders = (component: React.ReactElement) => {
+  return render(component, { wrapper: I18nProvider });
+};
+
+describe('WorkflowExecuteHistoricalForm', () => {
+  const defaultProps = {
+    workflowId: 'workflow-1',
+    value: '{}',
+    setValue: jest.fn(),
+    errors: null as string | null,
+    setErrors: jest.fn(),
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockUseWorkflowExecution.mockReturnValue({ data: null, isLoading: false });
+    mockUseWorkflowExecutions.mockReturnValue({ data: null });
+  });
+
+  describe('rendering', () => {
+    it('should render the execution combo box', () => {
+      renderWithProviders(<WorkflowExecuteHistoricalForm {...defaultProps} />);
+      expect(screen.getByTestId('workflowExecuteModalReplayExecutionComboBox')).toBeInTheDocument();
+    });
+
+    it('should render the select execution label', () => {
+      renderWithProviders(<WorkflowExecuteHistoricalForm {...defaultProps} />);
+      expect(screen.getByText('Select execution')).toBeInTheDocument();
+    });
+  });
+
+  describe('not-ready signaling', () => {
+    it('should set NOT_READY_SENTINEL error when no execution is selected', () => {
+      renderWithProviders(<WorkflowExecuteHistoricalForm {...defaultProps} />);
+      expect(defaultProps.setErrors).toHaveBeenCalledWith(NOT_READY_SENTINEL);
+    });
+
+    it('should set NOT_READY_SENTINEL error when execution is loading', () => {
+      mockUseWorkflowExecution.mockReturnValue({ data: null, isLoading: true });
+      renderWithProviders(
+        <WorkflowExecuteHistoricalForm {...defaultProps} initialExecutionId="exec-1" />
+      );
+      expect(defaultProps.setErrors).toHaveBeenCalledWith(NOT_READY_SENTINEL);
+    });
+  });
+
+  describe('execution loading', () => {
+    it('should show loading text when execution is loading', () => {
+      mockUseWorkflowExecution.mockReturnValue({ data: null, isLoading: true });
+      renderWithProviders(
+        <WorkflowExecuteHistoricalForm {...defaultProps} initialExecutionId="exec-1" />
+      );
+      expect(screen.getByText(/Loading execution/)).toBeInTheDocument();
+    });
+  });
+
+  describe('execution data population', () => {
+    it('should populate editor value and clear errors when execution data arrives', () => {
+      const mockExecution = {
+        id: 'exec-1',
+        context: { inputs: { key: 'value' }, event: { type: 'alert' } },
+      };
+      mockUseWorkflowExecution.mockReturnValue({ data: mockExecution, isLoading: false });
+      mockUseWorkflowExecutions.mockReturnValue({
+        data: {
+          total: 1,
+          results: [
+            {
+              id: 'exec-1',
+              startedAt: '2024-01-01T00:00:00Z',
+              isTestRun: false,
+              status: ExecutionStatus.COMPLETED,
+            },
+          ],
+        },
+      });
+
+      renderWithProviders(
+        <WorkflowExecuteHistoricalForm {...defaultProps} initialExecutionId="exec-1" />
+      );
+
+      expect(defaultProps.setValue).toHaveBeenCalledWith(
+        JSON.stringify({ key: 'value', event: { type: 'alert' } }, null, 2)
+      );
+      expect(defaultProps.setErrors).toHaveBeenCalledWith(null);
+    });
+
+    it('should extract only inputs when context has no event', () => {
+      const mockExecution = {
+        id: 'exec-1',
+        context: { inputs: { foo: 'bar' } },
+      };
+      mockUseWorkflowExecution.mockReturnValue({ data: mockExecution, isLoading: false });
+      mockUseWorkflowExecutions.mockReturnValue({
+        data: {
+          total: 1,
+          results: [
+            {
+              id: 'exec-1',
+              startedAt: '2024-01-01T00:00:00Z',
+              isTestRun: false,
+              status: ExecutionStatus.COMPLETED,
+            },
+          ],
+        },
+      });
+
+      renderWithProviders(
+        <WorkflowExecuteHistoricalForm {...defaultProps} initialExecutionId="exec-1" />
+      );
+
+      expect(defaultProps.setValue).toHaveBeenCalledWith(JSON.stringify({ foo: 'bar' }, null, 2));
+    });
+  });
+
+  describe('error callout', () => {
+    it('should not show error callout for NOT_READY_SENTINEL', () => {
+      const mockExecution = {
+        id: 'exec-1',
+        context: { inputs: {} },
+      };
+      mockUseWorkflowExecution.mockReturnValue({ data: mockExecution, isLoading: false });
+      mockUseWorkflowExecutions.mockReturnValue({
+        data: {
+          total: 1,
+          results: [
+            {
+              id: 'exec-1',
+              startedAt: '2024-01-01T00:00:00Z',
+              isTestRun: false,
+              status: ExecutionStatus.COMPLETED,
+            },
+          ],
+        },
+      });
+
+      renderWithProviders(
+        <WorkflowExecuteHistoricalForm
+          {...defaultProps}
+          initialExecutionId="exec-1"
+          errors={NOT_READY_SENTINEL}
+        />
+      );
+
+      expect(screen.queryByText('Invalid JSON')).not.toBeInTheDocument();
+    });
+
+    it('should show error callout for real JSON errors', () => {
+      const mockExecution = {
+        id: 'exec-1',
+        context: { inputs: {} },
+      };
+      mockUseWorkflowExecution.mockReturnValue({ data: mockExecution, isLoading: false });
+      mockUseWorkflowExecutions.mockReturnValue({
+        data: {
+          total: 1,
+          results: [
+            {
+              id: 'exec-1',
+              startedAt: '2024-01-01T00:00:00Z',
+              isTestRun: false,
+              status: ExecutionStatus.COMPLETED,
+            },
+          ],
+        },
+      });
+
+      renderWithProviders(
+        <WorkflowExecuteHistoricalForm
+          {...defaultProps}
+          initialExecutionId="exec-1"
+          errors="Unexpected token"
+        />
+      );
+
+      expect(screen.getByText('Unexpected token')).toBeInTheDocument();
+    });
+  });
+
+  describe('JSON validation on editor change', () => {
+    it('should clear errors when valid JSON is entered', () => {
+      const mockExecution = {
+        id: 'exec-1',
+        context: { inputs: {} },
+      };
+      mockUseWorkflowExecution.mockReturnValue({ data: mockExecution, isLoading: false });
+      mockUseWorkflowExecutions.mockReturnValue({
+        data: {
+          total: 1,
+          results: [
+            {
+              id: 'exec-1',
+              startedAt: '2024-01-01T00:00:00Z',
+              isTestRun: false,
+              status: ExecutionStatus.COMPLETED,
+            },
+          ],
+        },
+      });
+
+      renderWithProviders(
+        <WorkflowExecuteHistoricalForm
+          {...defaultProps}
+          initialExecutionId="exec-1"
+          value='{"key":"value"}'
+        />
+      );
+
+      const editor = screen.getByTestId('workflow-historical-json-editor');
+      fireEvent.change(editor, { target: { value: '{"valid": true}' } });
+
+      expect(defaultProps.setValue).toHaveBeenCalledWith('{"valid": true}');
+      expect(defaultProps.setErrors).toHaveBeenCalledWith(null);
+    });
+
+    it('should set error when invalid JSON is entered', () => {
+      const mockExecution = {
+        id: 'exec-1',
+        context: { inputs: {} },
+      };
+      mockUseWorkflowExecution.mockReturnValue({ data: mockExecution, isLoading: false });
+      mockUseWorkflowExecutions.mockReturnValue({
+        data: {
+          total: 1,
+          results: [
+            {
+              id: 'exec-1',
+              startedAt: '2024-01-01T00:00:00Z',
+              isTestRun: false,
+              status: ExecutionStatus.COMPLETED,
+            },
+          ],
+        },
+      });
+
+      renderWithProviders(
+        <WorkflowExecuteHistoricalForm
+          {...defaultProps}
+          initialExecutionId="exec-1"
+          value='{"key":"value"}'
+        />
+      );
+
+      const editor = screen.getByTestId('workflow-historical-json-editor');
+      fireEvent.change(editor, { target: { value: '{invalid' } });
+
+      expect(defaultProps.setValue).toHaveBeenCalledWith('{invalid');
+      expect(defaultProps.setErrors).toHaveBeenCalledWith('Invalid JSON');
+    });
+  });
+
+  describe('execution options', () => {
+    it('should show execution options in combo box', () => {
+      mockUseWorkflowExecutions.mockReturnValue({
+        data: {
+          total: 2,
+          results: [
+            {
+              id: 'exec-1',
+              startedAt: '2024-01-01T00:00:00Z',
+              isTestRun: false,
+              status: ExecutionStatus.COMPLETED,
+            },
+            {
+              id: 'exec-2',
+              startedAt: '2024-01-02T00:00:00Z',
+              isTestRun: true,
+              status: ExecutionStatus.COMPLETED,
+            },
+          ],
+        },
+      });
+
+      renderWithProviders(<WorkflowExecuteHistoricalForm {...defaultProps} />);
+
+      const comboBox = screen.getByTestId('workflowExecuteModalReplayExecutionComboBox');
+      expect(comboBox).toBeInTheDocument();
+    });
+
+    it('should pre-select execution when initialExecutionId is provided', () => {
+      mockUseWorkflowExecutions.mockReturnValue({
+        data: {
+          total: 1,
+          results: [
+            {
+              id: 'exec-1',
+              startedAt: '2024-01-01T00:00:00Z',
+              isTestRun: false,
+              status: ExecutionStatus.COMPLETED,
+            },
+          ],
+        },
+      });
+
+      renderWithProviders(
+        <WorkflowExecuteHistoricalForm {...defaultProps} initialExecutionId="exec-1" />
+      );
+
+      expect(mockUseWorkflowExecution).toHaveBeenCalledWith(
+        expect.objectContaining({ executionId: 'exec-1', enabled: true })
+      );
+    });
+  });
+});
diff --git a/src/platform/plugins/shared/workflows_management/public/features/run_workflow/ui/workflow_execute_historical_form.tsx b/src/platform/plugins/shared/workflows_management/public/features/run_workflow/ui/workflow_execute_historical_form.tsx
new file mode 100644
index 0000000000000..dbdea04cd1e3e
--- /dev/null
+++ b/src/platform/plugins/shared/workflows_management/public/features/run_workflow/ui/workflow_execute_historical_form.tsx
@@ -0,0 +1,268 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the "Elastic License
+ * 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side
+ * Public License v 1"; you may not use this file except in compliance with, at
+ * your election, the "Elastic License 2.0", the "GNU Affero General Public
+ * License v3.0 only", or the "Server Side Public License, v 1".
+ */
+
+import type { EuiComboBoxOptionOption } from '@elastic/eui';
+import {
+  EuiCallOut,
+  EuiComboBox,
+  EuiFlexGroup,
+  EuiFlexItem,
+  EuiFormRow,
+  EuiIconTip,
+  EuiSpacer,
+  EuiText,
+  useEuiTheme,
+} from '@elastic/eui';
+import { css } from '@emotion/react';
+import React, { useCallback, useEffect, useMemo, useState } from 'react';
+import { CodeEditor } from '@kbn/code-editor';
+import { i18n } from '@kbn/i18n';
+import { TRIGGER_TABS_LABELS } from './translations';
+import { useWorkflowExecution } from '../../../entities/workflows/model/use_workflow_execution';
+import { useWorkflowExecutions } from '../../../entities/workflows/model/use_workflow_executions';
+import { getExecutionStatusIcon } from '../../../shared/ui/status_badge';
+import { useGetFormattedDateTime } from '../../../shared/ui/use_formatted_date';
+import { WORKFLOWS_MONACO_EDITOR_THEME } from '../../../widgets/workflow_yaml_editor/styles/use_workflows_monaco_theme';
+
+/**
+ * Sentinel error value used to signal "not ready" to the parent (no execution
+ * selected, or execution still loading). The parent disables submit whenever
+ * `errors` is non-null, so this keeps the Run button disabled without
+ * displaying a visible error message.
+ */
+export const NOT_READY_SENTINEL = '__historical_not_ready__';
+
+export interface WorkflowExecuteHistoricalFormProps {
+  workflowId: string | undefined;
+  /** Pre-select this execution when the form mounts (e.g. from Replay button). */
+  initialExecutionId?: string;
+  value: string;
+  setValue: (value: string) => void;
+  errors: string | null;
+  setErrors: (errors: string | null) => void;
+}
+
+export const WorkflowExecuteHistoricalForm = React.memo<WorkflowExecuteHistoricalFormProps>(
+  ({ workflowId, initialExecutionId, value, setValue, errors, setErrors }) => {
+    const { euiTheme } = useEuiTheme();
+    const [selectedExecutionId, setSelectedExecutionId] = useState<string | null>(
+      initialExecutionId ?? null
+    );
+    const getFormattedDateTime = useGetFormattedDateTime();
+
+    const { data: executionsList } = useWorkflowExecutions({
+      workflowId: workflowId ?? null,
+      size: 100,
+    });
+
+    const executionOptions: EuiComboBoxOptionOption<string>[] = useMemo(() => {
+      const total = executionsList?.total ?? 0;
+      const results = executionsList?.results ?? [];
+      if (!results.length) return [];
+      return results.map((execution, index): EuiComboBoxOptionOption<string> => {
+        const runNumber = total - index;
+        const formattedDateTime =
+          getFormattedDateTime(new Date(execution.startedAt)) ?? execution.startedAt;
+        const statusIcon = getExecutionStatusIcon(euiTheme, execution.status);
+        return {
+          key: execution.id,
+          value: execution.id,
+          label: translations.getRunLabel(runNumber, formattedDateTime),
+          prepend: <EuiFlexItem grow={false}>{statusIcon}</EuiFlexItem>,
+          ...(execution.isTestRun && {
+            append: <EuiIconTip type="flask" aria-hidden={true} content={translations.testRun} />,
+          }),
+          css: css`
+            .euiComboBoxOption__append {
+              margin-top: 3px; /* align the icon with the text */
+            }
+          `,
+        };
+      });
+    }, [euiTheme, executionsList?.results, executionsList?.total, getFormattedDateTime]);
+
+    const { data: selectedExecution, isLoading: isLoadingExecution } = useWorkflowExecution({
+      executionId: selectedExecutionId,
+      enabled: selectedExecutionId !== null,
+    });
+
+    const replayInputsFromContext = useMemo((): Record<string, unknown> => {
+      if (!selectedExecution?.context) return {};
+      const ctx = selectedExecution.context as Record<string, unknown>;
+      return {
+        ...(typeof ctx.inputs === 'object' && ctx.inputs !== null ? (ctx.inputs as object) : {}),
+        ...(ctx.event !== undefined ? { event: ctx.event } : {}),
+      };
+    }, [selectedExecution?.context]);
+
+    // Signal "not ready" to the parent when no execution is selected or still loading
+    useEffect(() => {
+      if (!selectedExecutionId || isLoadingExecution) {
+        setErrors(NOT_READY_SENTINEL);
+      }
+    }, [selectedExecutionId, isLoadingExecution, setErrors]);
+
+    // Populate the editor when execution data arrives
+    useEffect(() => {
+      if (selectedExecution) {
+        setValue(JSON.stringify(replayInputsFromContext, null, 2));
+        setErrors(null);
+      }
+    }, [selectedExecution, replayInputsFromContext, setValue, setErrors]);
+
+    const handleExecutionChange = useCallback((selected: EuiComboBoxOptionOption<string>[]) => {
+      const id = selected.length > 0 && selected[0].value ? String(selected[0].value) : null;
+      setSelectedExecutionId(id);
+    }, []);
+
+    const handleChange = useCallback(
+      (newValue: string) => {
+        setValue(newValue);
+        try {
+          JSON.parse(newValue);
+          setErrors(null);
+        } catch {
+          setErrors(translations.invalidJson);
+        }
+      },
+      [setValue, setErrors]
+    );
+
+    return (
+      <EuiFlexGroup direction="column" gutterSize="l">
+        <EuiSpacer size="s" />
+        <EuiFlexItem grow={false}>
+          <EuiFormRow label={translations.selectExecutionLabel} fullWidth>
+            <EuiComboBox
+              singleSelection={{ asPlainText: true }}
+              options={executionOptions}
+              selectedOptions={
+                selectedExecutionId && executionOptions.length > 0
+                  ? executionOptions.filter((o) => o.key === selectedExecutionId)
+                  : []
+              }
+              onChange={handleExecutionChange}
+              isClearable
+              fullWidth
+              isLoading={!executionsList && !!workflowId}
+              placeholder={translations.selectExecutionPlaceholder}
+              data-test-subj="workflowExecuteModalReplayExecutionComboBox"
+            />
+          </EuiFormRow>
+        </EuiFlexItem>
+
+        {selectedExecution && (
+          <>
+            {errors && errors !== NOT_READY_SENTINEL && (
+              <EuiFlexItem grow={false}>
+                <EuiCallOut
+                  announceOnMount
+                  color="danger"
+                  size="s"
+                  title={translations.invalidJson}
+                >
+                  <p>{errors}</p>
+                </EuiCallOut>
+              </EuiFlexItem>
+            )}
+            <EuiFlexItem>
+              <EuiFormRow
+                label={translations.getInputDataLabel(
+                  getTriggerTypeLabel(selectedExecution.context)
+                )}
+                fullWidth
+              >
+                <CodeEditor
+                  languageId="json"
+                  value={value}
+                  fitToContent={{
+                    minLines: 5,
+                    maxLines: 15,
+                  }}
+                  width="100%"
+                  onChange={handleChange}
+                  dataTestSubj={'workflow-historical-json-editor'}
+                  options={{
+                    language: 'json',
+                    minimap: { enabled: false },
+                    scrollBeyondLastLine: false,
+                    wordWrap: 'on',
+                    automaticLayout: true,
+                    lineNumbers: 'on',
+                    glyphMargin: true,
+                    tabSize: 2,
+                    lineNumbersMinChars: 2,
+                    insertSpaces: true,
+                    fontSize: 14,
+                    renderWhitespace: 'all',
+                    wordWrapColumn: 80,
+                    wrappingIndent: 'indent',
+                    theme: WORKFLOWS_MONACO_EDITOR_THEME,
+                    formatOnType: true,
+                    quickSuggestions: false,
+                    suggestOnTriggerCharacters: false,
+                    wordBasedSuggestions: false,
+                    parameterHints: {
+                      enabled: false,
+                    },
+                  }}
+                />
+              </EuiFormRow>
+            </EuiFlexItem>
+          </>
+        )}
+        {selectedExecutionId && isLoadingExecution && (
+          <EuiFlexItem>
+            <EuiText size="s" color="subdued">
+              {translations.loadingExecution}
+            </EuiText>
+          </EuiFlexItem>
+        )}
+      </EuiFlexGroup>
+    );
+  }
+);
+WorkflowExecuteHistoricalForm.displayName = 'WorkflowExecuteHistoricalForm';
+
+function getTriggerTypeLabel(context?: Record<string, unknown>): string {
+  if (!context) return '';
+  const event = context?.event as Record<string, unknown>;
+  if (event?.alerts) return TRIGGER_TABS_LABELS.alert;
+  if (event?.documents) return TRIGGER_TABS_LABELS.index;
+  return TRIGGER_TABS_LABELS.manual;
+}
+
+const translations = {
+  getRunLabel: (runNumber: number, dateTime: string) =>
+    i18n.translate('workflows.workflowExecuteModal.replayOptionLabel', {
+      defaultMessage: 'Run #{runNumber} - {dateTime}',
+      values: { runNumber, dateTime },
+    }),
+  testRun: i18n.translate('workflows.workflowExecuteModal.testRun', {
+    defaultMessage: 'Test run',
+  }),
+  invalidJson: i18n.translate('workflows.workflowExecuteModal.invalidJson', {
+    defaultMessage: 'Invalid JSON',
+  }),
+  selectExecutionLabel: i18n.translate('workflows.workflowExecuteModal.selectExecutionLabel', {
+    defaultMessage: 'Select execution',
+  }),
+  selectExecutionPlaceholder: i18n.translate(
+    'workflows.workflowExecuteModal.selectExecutionPlaceholder',
+    { defaultMessage: 'Search or select a previous run' }
+  ),
+  getInputDataLabel: (originalTrigger: string) =>
+    i18n.translate('workflows.workflowExecuteModal.inputDataLabel', {
+      defaultMessage: 'Input data (original: {originalTrigger})',
+      values: { originalTrigger },
+    }),
+  loadingExecution: i18n.translate('workflows.workflowExecuteModal.loadingExecution', {
+    defaultMessage: 'Loading execution…',
+  }),
+};
diff --git a/src/platform/plugins/shared/workflows_management/public/features/run_workflow/ui/workflow_execute_index_form.tsx b/src/platform/plugins/shared/workflows_management/public/features/run_workflow/ui/workflow_execute_index_form.tsx
index a3f34211ef625..8b6f16292b7c5 100644
--- a/src/platform/plugins/shared/workflows_management/public/features/run_workflow/ui/workflow_execute_index_form.tsx
+++ b/src/platform/plugins/shared/workflows_management/public/features/run_workflow/ui/workflow_execute_index_form.tsx
@@ -385,10 +385,16 @@ export const WorkflowExecuteIndexForm = ({
   return (
     <EuiFlexGroup direction="column" gutterSize="s">
       <EuiSpacer size="s" />
-      <EuiFlexGroup direction="row" gutterSize="s">
+      <EuiFlexGroup direction="row" gutterSize="none">
         {/* Data View Selector */}
         <EuiFlexItem grow={false}>
-          <EuiPanel paddingSize="s" hasBorder={false} hasShadow={false} color="transparent">
+          <EuiPanel
+            paddingSize="s"
+            hasBorder={false}
+            hasShadow={false}
+            color="transparent"
+            css={{ paddingRight: 0 }}
+          >
             <DataViewPicker
               trigger={{
                 'data-test-subj': 'workflow-data-view-selector',
diff --git a/src/platform/plugins/shared/workflows_management/public/features/run_workflow/ui/workflow_execute_modal.test.tsx b/src/platform/plugins/shared/workflows_management/public/features/run_workflow/ui/workflow_execute_modal.test.tsx
index 416956692a7db..d563356390a47 100644
--- a/src/platform/plugins/shared/workflows_management/public/features/run_workflow/ui/workflow_execute_modal.test.tsx
+++ b/src/platform/plugins/shared/workflows_management/public/features/run_workflow/ui/workflow_execute_modal.test.tsx
@@ -34,6 +34,14 @@ const mockWorkflowExecuteManualForm = jest.fn(() => null);
 jest.mock('./workflow_execute_manual_form', () => ({
   WorkflowExecuteManualForm: () => mockWorkflowExecuteManualForm(),
 }));
+const mockWorkflowExecuteHistoricalForm = jest.fn(() => null);
+jest.mock('./workflow_execute_historical_form', () => ({
+  WorkflowExecuteHistoricalForm: () => mockWorkflowExecuteHistoricalForm(),
+}));
+
+jest.mock('../../../entities/workflows/model/use_workflow_execution', () => ({
+  useWorkflowExecution: () => ({ data: null, isLoading: false }),
+}));
 
 // Mock the translations
 jest.mock('../../../../common/translations', () => ({
@@ -59,6 +67,7 @@ describe('WorkflowExecuteModal', () => {
     mockWorkflowExecuteEventForm.mockClear();
     mockWorkflowExecuteIndexForm.mockClear();
     mockWorkflowExecuteManualForm.mockClear();
+    mockWorkflowExecuteHistoricalForm.mockClear();
   });
 
   describe('Basic rendering', () => {
@@ -86,8 +95,9 @@ describe('WorkflowExecuteModal', () => {
       );
 
       expect(getByText('Alert')).toBeInTheDocument();
-      expect(getByText('Index')).toBeInTheDocument();
+      expect(getByText('Document')).toBeInTheDocument();
       expect(getByText('Manual')).toBeInTheDocument();
+      expect(getByText('Historical')).toBeInTheDocument();
     });
 
     it('renders trigger descriptions', () => {
@@ -100,9 +110,10 @@ describe('WorkflowExecuteModal', () => {
         />
       );
 
-      expect(getByText('Manual trigger description')).toBeInTheDocument();
-      expect(getByText('Index trigger description')).toBeInTheDocument();
-      expect(getByText('Alert trigger description')).toBeInTheDocument();
+      expect(getByText('Provide custom JSON data manually.')).toBeInTheDocument();
+      expect(getByText('Choose a document from Elasticsearch.')).toBeInTheDocument();
+      expect(getByText('Choose an existing alert directly.')).toBeInTheDocument();
+      expect(getByText('Reuse input data from previous executions.')).toBeInTheDocument();
     });
 
     it('renders the execute button', () => {
@@ -168,7 +179,7 @@ describe('WorkflowExecuteModal', () => {
         />
       );
 
-      const indexButton = getByText('Index').closest('button');
+      const indexButton = getByText('Document').closest('button');
       fireEvent.click(indexButton!);
 
       await waitFor(() => {
@@ -235,8 +246,8 @@ describe('WorkflowExecuteModal', () => {
       // Initially, event form should be called (alert is default)
       expect(mockWorkflowExecuteEventForm).toHaveBeenCalledTimes(1);
 
-      // Click index trigger
-      const indexButton = getByText('Index').closest('button');
+      // Click index (Document) trigger
+      const indexButton = getByText('Document').closest('button');
       fireEvent.click(indexButton!);
 
       await waitFor(() => {
@@ -380,6 +391,63 @@ describe('WorkflowExecuteModal', () => {
     });
   });
 
+  describe('Historical trigger', () => {
+    it('defaults to historical tab when initialExecutionId is provided', () => {
+      const { getByText } = renderWithProviders(
+        <WorkflowExecuteModal
+          isTestRun={false}
+          definition={null}
+          onClose={mockOnClose}
+          onSubmit={mockOnSubmit}
+          initialExecutionId="exec-123"
+        />
+      );
+
+      const historicalButton = getByText('Historical').closest('button');
+      const historicalRadio = historicalButton?.querySelector('input[type="radio"]');
+      expect(historicalRadio).toBeChecked();
+    });
+
+    it('renders historical form when historical trigger is clicked', async () => {
+      const { getByText } = renderWithProviders(
+        <WorkflowExecuteModal
+          isTestRun={false}
+          definition={null}
+          onClose={mockOnClose}
+          onSubmit={mockOnSubmit}
+        />
+      );
+
+      const historicalButton = getByText('Historical').closest('button');
+      fireEvent.click(historicalButton!);
+
+      await waitFor(() => {
+        expect(mockWorkflowExecuteHistoricalForm).toHaveBeenCalled();
+      });
+    });
+
+    it('should keep historical tab when initialExecutionId is set and definition has alert triggers', () => {
+      const { getByText } = renderWithProviders(
+        <WorkflowExecuteModal
+          isTestRun={false}
+          definition={{
+            ...baseWorkflowDefinition,
+            triggers: [{ type: 'alert' }],
+          }}
+          onClose={mockOnClose}
+          onSubmit={mockOnSubmit}
+          initialExecutionId="exec-123"
+        />
+      );
+
+      // Without initialExecutionId, the useEffect would switch to 'alert'.
+      // With initialExecutionId, it skips the default trigger selection.
+      const historicalButton = getByText('Historical').closest('button');
+      const historicalRadio = historicalButton?.querySelector('input[type="radio"]');
+      expect(historicalRadio).toBeChecked();
+    });
+  });
+
   describe('Modal close functionality', () => {
     it('calls onClose when modal close button is clicked', () => {
       const { container } = renderWithProviders(
diff --git a/src/platform/plugins/shared/workflows_management/public/features/run_workflow/ui/workflow_execute_modal.tsx b/src/platform/plugins/shared/workflows_management/public/features/run_workflow/ui/workflow_execute_modal.tsx
index 3693195b09f74..f4198df662bf8 100644
--- a/src/platform/plugins/shared/workflows_management/public/features/run_workflow/ui/workflow_execute_modal.tsx
+++ b/src/platform/plugins/shared/workflows_management/public/features/run_workflow/ui/workflow_execute_modal.tsx
@@ -22,23 +22,22 @@ import {
   useGeneratedHtmlId,
 } from '@elastic/eui';
 import { css, Global } from '@emotion/react';
-import { capitalize } from 'lodash';
 import React, { useCallback, useEffect, useMemo, useState } from 'react';
 import { parseDocument } from 'yaml';
 import { i18n } from '@kbn/i18n';
 import { FormattedMessage } from '@kbn/i18n-react';
 import type { WorkflowYaml } from '@kbn/workflows';
 import { normalizeInputsToJsonSchema } from '@kbn/workflows/spec/lib/input_conversion';
+import { ENABLED_TRIGGER_TABS } from './constants';
+import { TRIGGER_TABS_DESCRIPTIONS, TRIGGER_TABS_LABELS } from './translations';
+import type { WorkflowTriggerTab } from './types';
 import { useExecutionInput } from './use_execution_input/use_execution_input';
 import { WorkflowExecuteEventForm } from './workflow_execute_event_form';
+import { WorkflowExecuteHistoricalForm } from './workflow_execute_historical_form';
 import { WorkflowExecuteIndexForm } from './workflow_execute_index_form';
 import { WorkflowExecuteManualForm } from './workflow_execute_manual_form';
-import { MANUAL_TRIGGERS_DESCRIPTIONS } from '../../../../common/translations';
-import type { WorkflowTriggerTab } from '../../../common/lib/telemetry/events/workflows/execution/types';
 
-type TriggerType = 'manual' | 'index' | 'alert';
-
-function getDefaultTrigger(definition: WorkflowYaml | null): TriggerType {
+function getDefaultTrigger(definition: WorkflowYaml | null): WorkflowTriggerTab {
   if (!definition) {
     return 'alert';
   }
@@ -55,20 +54,23 @@ function getDefaultTrigger(definition: WorkflowYaml | null): TriggerType {
   return 'alert';
 }
 
-interface WorkflowExecuteModalProps {
+export interface WorkflowExecuteModalProps {
   definition: WorkflowYaml | null;
   workflowId?: string;
   isTestRun: boolean;
   onClose: () => void;
-  onSubmit: (data: Record<string, unknown>, triggerTab?: WorkflowTriggerTab) => void;
+  onSubmit: (data: Record<string, unknown>, triggerTab: WorkflowTriggerTab) => void;
   yamlString?: string;
+  /** When set, open with Historical tab and this execution pre-selected */
+  initialExecutionId?: string;
 }
 export const WorkflowExecuteModal = React.memo<WorkflowExecuteModalProps>(
-  ({ definition, workflowId, onClose, onSubmit, isTestRun, yamlString }) => {
+  ({ definition, workflowId, onClose, onSubmit, isTestRun, yamlString, initialExecutionId }) => {
     const modalTitleId = useGeneratedHtmlId();
-    const enabledTriggers = ['alert', 'index', 'manual'];
-    const defaultTrigger = useMemo(() => getDefaultTrigger(definition), [definition]);
-    const [selectedTrigger, setSelectedTrigger] = useState<TriggerType>(defaultTrigger);
+
+    const [selectedTrigger, setSelectedTrigger] = useState<WorkflowTriggerTab>(() =>
+      initialExecutionId ? 'historical' : getDefaultTrigger(definition)
+    );
 
     const { executionInput, setExecutionInput } = useExecutionInput({
       workflowName: definition?.name || '',
@@ -82,14 +84,15 @@ export const WorkflowExecuteModal = React.memo<WorkflowExecuteModalProps>(
     const handleSubmit = useCallback(() => {
       onSubmit(JSON.parse(executionInput), selectedTrigger);
       onClose();
-    }, [onSubmit, onClose, executionInput, selectedTrigger]);
+    }, [selectedTrigger, onSubmit, onClose, executionInput]);
 
     const handleChangeTrigger = useCallback(
-      (trigger: TriggerType): void => {
+      (trigger: WorkflowTriggerTab): void => {
         setExecutionInput('');
+        setExecutionInputErrors(null);
         setSelectedTrigger(trigger);
       },
-      [setExecutionInput, setSelectedTrigger]
+      [setExecutionInput]
     );
 
     // Extract inputs from yamlString if definition.inputs is undefined
@@ -128,11 +131,14 @@ export const WorkflowExecuteModal = React.memo<WorkflowExecuteModalProps>(
 
     useEffect(() => {
       if (shouldAutoRun) {
-        onSubmit({}, 'manual'); // Auto-run defaults to manual trigger
+        onSubmit({}, 'manual');
         onClose();
         return;
       }
-      // Default trigger selection
+      if (initialExecutionId) {
+        return;
+      }
+      // Default trigger selection when no initialExecutionId
       if (definition?.triggers?.some((trigger) => trigger.type === 'alert')) {
         setSelectedTrigger('alert');
         return;
@@ -144,7 +150,7 @@ export const WorkflowExecuteModal = React.memo<WorkflowExecuteModalProps>(
       if (hasInputs) {
         setSelectedTrigger('manual');
       }
-    }, [shouldAutoRun, onSubmit, onClose, definition, inputs]);
+    }, [shouldAutoRun, onSubmit, onClose, definition, inputs, initialExecutionId]);
 
     if (shouldAutoRun) {
       // Not rendered if the workflow should auto run, will close the modal automatically
@@ -202,86 +208,102 @@ export const WorkflowExecuteModal = React.memo<WorkflowExecuteModalProps>(
             </EuiModalHeaderTitle>
           </EuiModalHeader>
           <EuiModalBody>
-            <EuiFlexGroup direction="row" gutterSize="l">
-              {enabledTriggers.map((trigger) => (
-                <EuiFlexItem key={trigger}>
-                  <EuiButton
-                    color={selectedTrigger === trigger ? 'primary' : 'text'}
-                    onClick={() => handleChangeTrigger(trigger as TriggerType)}
-                    iconSide="right"
-                    contentProps={{
-                      style: {
-                        justifyContent: 'flex-start',
-                        flexDirection: 'column',
-                        alignItems: 'flex-start',
-                        padding: selectedTrigger === trigger ? '10px' : '9px',
-                        textAlign: 'left',
-                      },
-                    }}
-                    css={css`
-                      width: 100%;
-                      height: fit-content;
-                      min-height: 100%;
-                      svg,
-                      img {
-                        margin-left: auto;
-                      }
-                    `}
-                  >
-                    <EuiRadio
-                      name={capitalize(trigger)}
-                      label={capitalize(trigger)}
-                      id={trigger}
-                      checked={selectedTrigger === trigger}
-                      onChange={() => {}}
-                    />
-                    <EuiText
-                      size="s"
-                      css={css`
-                        text-wrap: auto;
-                        margin-left: ${euiTheme.size.l};
-                      `}
-                    >
-                      {MANUAL_TRIGGERS_DESCRIPTIONS[trigger]}
-                    </EuiText>
-                  </EuiButton>
-                </EuiFlexItem>
-              ))}
-            </EuiFlexGroup>
+            <EuiFlexGroup direction="column" gutterSize="m">
+              <EuiFlexItem>
+                <EuiFlexGroup direction="row" gutterSize="s">
+                  {ENABLED_TRIGGER_TABS.map((trigger) => (
+                    <EuiFlexItem key={trigger}>
+                      <EuiButton
+                        color={selectedTrigger === trigger ? 'primary' : 'text'}
+                        onClick={() => handleChangeTrigger(trigger)}
+                        iconSide="right"
+                        contentProps={{
+                          style: {
+                            justifyContent: 'flex-start',
+                            flexDirection: 'column',
+                            alignItems: 'flex-start',
+                            padding: selectedTrigger === trigger ? '10px' : '9px',
+                            textAlign: 'left',
+                          },
+                        }}
+                        css={css`
+                          width: 100%;
+                          height: fit-content;
+                          min-height: 100%;
+                          svg,
+                          img {
+                            margin-left: auto;
+                          }
+                        `}
+                      >
+                        <EuiRadio
+                          name={TRIGGER_TABS_LABELS[trigger]}
+                          label={TRIGGER_TABS_LABELS[trigger]}
+                          id={trigger}
+                          checked={selectedTrigger === trigger}
+                          onChange={() => {}}
+                        />
+                        <EuiText
+                          size="s"
+                          css={css`
+                            text-wrap: auto;
+                            margin-left: ${euiTheme.size.l};
+                          `}
+                        >
+                          {TRIGGER_TABS_DESCRIPTIONS[trigger]}
+                        </EuiText>
+                      </EuiButton>
+                    </EuiFlexItem>
+                  ))}
+                </EuiFlexGroup>
+              </EuiFlexItem>
 
-            {selectedTrigger === 'alert' && (
-              <WorkflowExecuteEventForm
-                value={executionInput}
-                setValue={setExecutionInput}
-                errors={executionInputErrors}
-                setErrors={setExecutionInputErrors}
-              />
-            )}
-            {selectedTrigger === 'manual' && (
-              <WorkflowExecuteManualForm
-                definition={
-                  definition
-                    ? {
-                        ...definition,
-                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                        inputs: inputs as any,
-                      }
-                    : null
-                }
-                value={executionInput}
-                errors={executionInputErrors}
-                setErrors={setExecutionInputErrors}
-                setValue={setExecutionInput}
-              />
-            )}
-            {selectedTrigger === 'index' && (
-              <WorkflowExecuteIndexForm
-                value={executionInput}
-                setValue={setExecutionInput}
-                errors={executionInputErrors}
-                setErrors={setExecutionInputErrors}
-              />
-            )}
+              <EuiFlexItem>
+                {selectedTrigger === 'alert' && (
+                  <WorkflowExecuteEventForm
+                    value={executionInput}
+                    setValue={setExecutionInput}
+                    errors={executionInputErrors}
+                    setErrors={setExecutionInputErrors}
+                  />
+                )}
+                {selectedTrigger === 'manual' && (
+                  <WorkflowExecuteManualForm
+                    definition={
+                      definition
+                        ? {
+                            ...definition,
+                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                            inputs: inputs as any,
+                          }
+                        : null
+                    }
+                    value={executionInput}
+                    errors={executionInputErrors}
+                    setErrors={setExecutionInputErrors}
+                    setValue={setExecutionInput}
+                  />
+                )}
+                {selectedTrigger === 'index' && (
+                  <WorkflowExecuteIndexForm
+                    value={executionInput}
+                    setValue={setExecutionInput}
+                    errors={executionInputErrors}
+                    setErrors={setExecutionInputErrors}
+                  />
+                )}
+                {selectedTrigger === 'historical' && (
+                  <WorkflowExecuteHistoricalForm
+                    workflowId={workflowId}
+                    initialExecutionId={initialExecutionId}
+                    value={executionInput}
+                    setValue={setExecutionInput}
+                    errors={executionInputErrors}
+                    setErrors={setExecutionInputErrors}
+                  />
+                )}
+              </EuiFlexItem>
+            </EuiFlexGroup>
           </EuiModalBody>
           <EuiModalFooter>
             <EuiButton
diff --git a/src/platform/plugins/shared/workflows_management/public/features/workflow_execution_detail/ui/workflow_execution_panel.test.tsx b/src/platform/plugins/shared/workflows_management/public/features/workflow_execution_detail/ui/workflow_execution_panel.test.tsx
index 74e0200ac235b..d5b1e4ba4ab9e 100644
--- a/src/platform/plugins/shared/workflows_management/public/features/workflow_execution_detail/ui/workflow_execution_panel.test.tsx
+++ b/src/platform/plugins/shared/workflows_management/public/features/workflow_execution_detail/ui/workflow_execution_panel.test.tsx
@@ -12,8 +12,14 @@ import React from 'react';
 import type { WorkflowExecutionDto, WorkflowYaml } from '@kbn/workflows';
 import { ExecutionStatus } from '@kbn/workflows';
 import { WorkflowExecutionPanel } from './workflow_execution_panel';
+import { setYamlString } from '../../../entities/workflows/store';
+import { createMockStore } from '../../../entities/workflows/store/__mocks__/store.mock';
+import { mockCapabilities } from '../../../hooks/__mocks__/use_capabilities';
+import { useCapabilities } from '../../../hooks/use_capabilities';
 import { TestWrapper } from '../../../shared/test_utils';
 
+jest.mock('../../../hooks/use_capabilities');
+
 // Mock child components
 jest.mock('./cancel_execution_button', () => ({
   CancelExecutionButton: ({ executionId }: { executionId: string }) => (
@@ -96,13 +102,20 @@ describe('WorkflowExecutionPanel', () => {
     onClose: jest.fn(),
   };
 
+  let mockStore: ReturnType<
+    typeof import('../../../shared/test_utils/test_wrapper').TestWrapper extends any ? any : never
+  >;
+
   beforeEach(() => {
     jest.clearAllMocks();
+    mockStore = undefined;
+    jest.mocked(useCapabilities).mockReturnValue(mockCapabilities);
   });
 
-  const renderComponent = (props = {}) => {
+  const renderComponent = (props = {}, store?: any) => {
+    mockStore = store;
     return render(
-      <TestWrapper>
+      <TestWrapper store={mockStore}>
         <WorkflowExecutionPanel {...defaultProps} {...props} />
       </TestWrapper>
     );
@@ -278,6 +291,89 @@ describe('WorkflowExecutionPanel', () => {
     });
   });
 
+  describe('replay button', () => {
+    it('should show replay button when done button is visible', () => {
+      renderComponent({
+        showBackButton: false,
+        execution: { ...mockExecution, status: ExecutionStatus.COMPLETED },
+      });
+      expect(screen.getByTestId('replayExecutionButton')).toBeInTheDocument();
+    });
+
+    it('should not show replay button when execution is still running', () => {
+      renderComponent({
+        showBackButton: false,
+        execution: { ...mockExecution, status: ExecutionStatus.RUNNING },
+      });
+      expect(screen.queryByTestId('replayExecutionButton')).not.toBeInTheDocument();
+    });
+
+    it('should not show replay button when showBackButton is true', () => {
+      renderComponent({
+        showBackButton: true,
+        execution: { ...mockExecution, status: ExecutionStatus.COMPLETED },
+      });
+      expect(screen.queryByTestId('replayExecutionButton')).not.toBeInTheDocument();
+    });
+
+    it('should dispatch setReplayExecutionId and setIsTestModalOpen on click', () => {
+      const store = createMockStore();
+
+      store.dispatch(setYamlString(mockExecution.yaml)); // starts computation to detect syntax errors
+
+      renderComponent(
+        {
+          showBackButton: false,
+          execution: { ...mockExecution, status: ExecutionStatus.COMPLETED },
+        },
+        store
+      );
+
+      fireEvent.click(screen.getByTestId('replayExecutionButton'));
+
+      const state = store.getState();
+      expect(state.detail.replayExecutionId).toBe('exec-123');
+      expect(state.detail.isTestModalOpen).toBe(true);
+    });
+
+    it('should disable replay button when user lacks execute capability', () => {
+      jest.mocked(useCapabilities).mockReturnValue({
+        ...mockCapabilities,
+        canExecuteWorkflow: false,
+      });
+
+      const store = createMockStore();
+      store.dispatch(setYamlString(mockExecution.yaml));
+
+      renderComponent(
+        {
+          showBackButton: false,
+          execution: { ...mockExecution, status: ExecutionStatus.COMPLETED },
+        },
+        store
+      );
+
+      const replayButton = screen.getByTestId('replayExecutionButton');
+      expect(replayButton).toBeDisabled();
+    });
+
+    it('should disable replay button when YAML syntax is invalid', () => {
+      const store = createMockStore();
+      store.dispatch(setYamlString('')); // empty yaml clears computed, making syntax invalid
+
+      renderComponent(
+        {
+          showBackButton: false,
+          execution: { ...mockExecution, status: ExecutionStatus.COMPLETED },
+        },
+        store
+      );
+
+      const replayButton = screen.getByTestId('replayExecutionButton');
+      expect(replayButton).toBeDisabled();
+    });
+  });
+
   describe('edge cases', () => {
     it('should handle all props being null/empty', () => {
       renderComponent({
diff --git a/src/platform/plugins/shared/workflows_management/public/features/workflow_execution_detail/ui/workflow_execution_panel.tsx b/src/platform/plugins/shared/workflows_management/public/features/workflow_execution_detail/ui/workflow_execution_panel.tsx
index 67268d8dc0999..065cba6b122a8 100644
--- a/src/platform/plugins/shared/workflows_management/public/features/workflow_execution_detail/ui/workflow_execution_panel.tsx
+++ b/src/platform/plugins/shared/workflows_management/public/features/workflow_execution_detail/ui/workflow_execution_panel.tsx
@@ -10,6 +10,7 @@
 import type { UseEuiTheme } from '@elastic/eui';
 import {
   EuiButton,
+  EuiButtonIcon,
   EuiFlexGroup,
   EuiFlexItem,
   EuiHorizontalRule,
@@ -17,15 +18,24 @@ import {
   EuiLink,
   EuiPanel,
   EuiTitle,
+  EuiToolTip,
 } from '@elastic/eui';
 import { css } from '@emotion/react';
-import React, { useMemo } from 'react';
+import React, { useCallback, useMemo } from 'react';
+import { useDispatch, useSelector } from 'react-redux';
 import { useMemoCss } from '@kbn/css-utils/public/use_memo_css';
 import { i18n } from '@kbn/i18n';
 import type { WorkflowExecutionDto, WorkflowYaml } from '@kbn/workflows';
 import { isCancelableStatus, isTerminalStatus } from '@kbn/workflows';
 import { CancelExecutionButton } from './cancel_execution_button';
 import { WorkflowStepExecutionTree } from './workflow_step_execution_tree';
+import { selectIsYamlSyntaxValid } from '../../../entities/workflows/store/workflow_detail/selectors';
+import {
+  setIsTestModalOpen,
+  setReplayExecutionId,
+} from '../../../entities/workflows/store/workflow_detail/slice';
+import { useCapabilities } from '../../../hooks/use_capabilities';
+import { getTestRunTooltipContent } from '../../../shared/ui/workflow_action_buttons/get_workflow_tooltip_content';
 
 const i18nTexts = {
   backToExecutions: i18n.translate('workflows.workflowStepExecutionList.backToExecution', {
@@ -34,6 +44,9 @@ const i18nTexts = {
   done: i18n.translate('workflows.workflowStepExecutionList.done', {
     defaultMessage: 'Done',
   }),
+  replay: i18n.translate('workflows.workflowStepExecutionList.replay', {
+    defaultMessage: 'Run again',
+  }),
 };
 
 export interface WorkflowExecutionPanelProps {
@@ -85,7 +98,7 @@ export const WorkflowExecutionPanel = React.memo<WorkflowExecutionPanelProps>(
               <EuiPanel paddingSize="m" hasShadow={false} css={styles.linkCss}>
                 <EuiFlexGroup alignItems="center" justifyContent="flexStart" gutterSize="s">
                   <EuiFlexItem grow={false}>
-                    <EuiIcon type="sortLeft" />
+                    <EuiIcon type="sortLeft" aria-hidden={true} />
                   </EuiFlexItem>
                   <EuiFlexItem grow={false}>
                     <EuiTitle size="xxs">
@@ -111,11 +124,11 @@ export const WorkflowExecutionPanel = React.memo<WorkflowExecutionPanelProps>(
           </EuiPanel>
         </EuiFlexItem>
 
-        {(showDoneButton || showCancelButton) && (
+        {execution && (showCancelButton || showDoneButton) && (
           <EuiFlexItem grow={false}>
             <EuiHorizontalRule margin="none" />
             <EuiPanel paddingSize="m" hasShadow={false}>
-              {showCancelButton && execution ? (
+              {showCancelButton ? (
                 <CancelExecutionButton
                   executionId={execution.id}
                   workflowId={execution.workflowId}
@@ -124,15 +137,22 @@ export const WorkflowExecutionPanel = React.memo<WorkflowExecutionPanelProps>(
               ) : (
                 <>
                   {showDoneButton && (
-                    <EuiButton
-                      onClick={onClose}
-                      iconType="check"
-                      size="s"
-                      fullWidth
-                      aria-label={i18nTexts.done}
-                    >
-                      {i18nTexts.done}
-                    </EuiButton>
+                    <EuiFlexGroup alignItems="center" justifyContent="flexStart" gutterSize="s">
+                      <EuiFlexItem grow={!showDoneButton}>
+                        <ReplayExecutionButton executionId={execution.id} />
+                      </EuiFlexItem>
+                      <EuiFlexItem>
+                        <EuiButton
+                          onClick={onClose}
+                          iconType="check"
+                          size="s"
+                          fullWidth
+                          aria-label={i18nTexts.done}
+                        >
+                          {i18nTexts.done}
+                        </EuiButton>
+                      </EuiFlexItem>
+                    </EuiFlexGroup>
                   )}
                 </>
               )}
@@ -153,3 +173,43 @@ const componentStyles = {
       },
     }),
 };
+
+const ReplayExecutionButton = React.memo<{ executionId: string }>(({ executionId }) => {
+  const dispatch = useDispatch();
+  const replayExecution = useCallback(() => {
+    dispatch(setReplayExecutionId(executionId));
+    dispatch(setIsTestModalOpen(true));
+  }, [executionId, dispatch]);
+
+  const isSyntaxValid = useSelector(selectIsYamlSyntaxValid);
+  const { canExecuteWorkflow } = useCapabilities();
+  const { isRunDisabled, runDisabledTooltipContent } = useMemo<{
+    isRunDisabled: boolean;
+    runDisabledTooltipContent: string | null;
+  }>(() => {
+    return {
+      isRunDisabled: !canExecuteWorkflow || !isSyntaxValid,
+      runDisabledTooltipContent: getTestRunTooltipContent({
+        isValid: isSyntaxValid,
+        canRunWorkflow: canExecuteWorkflow,
+        isExecutionsTab: false,
+      }),
+    };
+  }, [canExecuteWorkflow, isSyntaxValid]);
+
+  return (
+    <EuiToolTip content={runDisabledTooltipContent ?? i18nTexts.replay} disableScreenReaderOutput>
+      <EuiButtonIcon
+        onClick={replayExecution}
+        iconType="refresh"
+        size="s"
+        color="success"
+        aria-label={i18nTexts.replay}
+        display="base"
+        data-test-subj="replayExecutionButton"
+        disabled={isRunDisabled}
+      />
+    </EuiToolTip>
+  );
+});
+ReplayExecutionButton.displayName = 'ReplayExecutionButton';
diff --git a/src/platform/plugins/shared/workflows_management/public/features/workflow_execution_detail/ui/workflow_pseudo_step_context.test.ts b/src/platform/plugins/shared/workflows_management/public/features/workflow_execution_detail/ui/workflow_pseudo_step_context.test.ts
new file mode 100644
index 0000000000000..b460e6acb4f39
--- /dev/null
+++ b/src/platform/plugins/shared/workflows_management/public/features/workflow_execution_detail/ui/workflow_pseudo_step_context.test.ts
@@ -0,0 +1,66 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the "Elastic License
+ * 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side
+ * Public License v 1"; you may not use this file except in compliance with, at
+ * your election, the "Elastic License 2.0", the "GNU Affero General Public
+ * License v3.0 only", or the "Server Side Public License, v 1".
+ */
+
+import { buildTriggerContextFromExecution } from './workflow_pseudo_step_context';
+
+describe('buildTriggerContextFromExecution', () => {
+  it('should return null when context is null', () => {
+    expect(buildTriggerContextFromExecution(null)).toBeNull();
+  });
+
+  it('should return null when context is undefined', () => {
+    expect(buildTriggerContextFromExecution(undefined)).toBeNull();
+  });
+
+  it('should return manual trigger type when context has no event', () => {
+    const result = buildTriggerContextFromExecution({ inputs: { key: 'value' } });
+    expect(result).toEqual({
+      triggerType: 'manual',
+      input: { key: 'value' },
+    });
+  });
+
+  it('should return scheduled trigger type when event type is scheduled', () => {
+    const event = { type: 'scheduled', data: 'test' };
+    const result = buildTriggerContextFromExecution({ event });
+    expect(result).toEqual({
+      triggerType: 'scheduled',
+      input: event,
+    });
+  });
+
+  it('should return alert trigger type when event has alerts', () => {
+    const event = { alerts: [{ id: 'alert-1' }] };
+    const result = buildTriggerContextFromExecution({ event });
+    expect(result).toEqual({
+      triggerType: 'alert',
+      input: event,
+    });
+  });
+
+  it('should return document trigger type when event has no alerts and is not scheduled', () => {
+    const event = { documents: [{ id: 'doc-1' }] };
+    const result = buildTriggerContextFromExecution({ event });
+    expect(result).toEqual({
+      triggerType: 'document',
+      input: event,
+    });
+  });
+
+  it('should use event as input when event is present', () => {
+    const event = { alerts: [{ id: 'alert-1' }] };
+    const result = buildTriggerContextFromExecution({ event, inputs: { ignored: true } });
+    expect(result?.input).toEqual(event);
+  });
+
+  it('should use inputs as input when event is not present', () => {
+    const result = buildTriggerContextFromExecution({ inputs: { foo: 'bar' } });
+    expect(result?.input).toEqual({ foo: 'bar' });
+  });
+});
diff --git a/src/platform/plugins/shared/workflows_management/public/features/workflow_execution_detail/ui/workflow_pseudo_step_context.ts b/src/platform/plugins/shared/workflows_management/public/features/workflow_execution_detail/ui/workflow_pseudo_step_context.ts
index 9f721886df1a7..131368d78c877 100644
--- a/src/platform/plugins/shared/workflows_management/public/features/workflow_execution_detail/ui/workflow_pseudo_step_context.ts
+++ b/src/platform/plugins/shared/workflows_management/public/features/workflow_execution_detail/ui/workflow_pseudo_step_context.ts
@@ -11,7 +11,7 @@ import type { JsonValue } from '@kbn/utility-types';
 import type { WorkflowExecutionDto, WorkflowStepExecutionDto } from '@kbn/workflows';
 import { ExecutionStatus } from '@kbn/workflows';
 
-export type TriggerType = 'alert' | 'scheduled' | 'manual';
+export type TriggerType = 'alert' | 'scheduled' | 'manual' | 'document';
 
 export interface TriggerContextFromExecution {
   triggerType: TriggerType;
@@ -24,17 +24,19 @@ export function buildTriggerContextFromExecution(
   if (!executionContext) {
     return null;
   }
-
   let triggerType: TriggerType = 'manual'; // Default to manual trigger type
 
-  const hasEvent = executionContext.event !== undefined;
   const isScheduled =
     (executionContext.event as { type?: string } | undefined)?.type === 'scheduled';
 
   if (isScheduled) {
     triggerType = 'scheduled';
-  } else if (hasEvent) {
-    triggerType = 'alert';
+  } else if (executionContext.event != null) {
+    if ((executionContext.event as Record<string, unknown>).alerts != null) {
+      triggerType = 'alert';
+    } else {
+      triggerType = 'document';
+    }
   }
 
   const inputData = (executionContext as { event?: JsonValue; inputs?: JsonValue }).event
diff --git a/src/platform/plugins/shared/workflows_management/public/features/workflow_list/ui/workflow_list.tsx b/src/platform/plugins/shared/workflows_management/public/features/workflow_list/ui/workflow_list.tsx
index 6ea077ff43029..357b877c44584 100644
--- a/src/platform/plugins/shared/workflows_management/public/features/workflow_list/ui/workflow_list.tsx
+++ b/src/platform/plugins/shared/workflows_management/public/features/workflow_list/ui/workflow_list.tsx
@@ -38,6 +38,7 @@ import { NextExecutionTime } from '../../../shared/ui/next_execution_time';
 import { shouldShowWorkflowsEmptyState } from '../../../shared/utils/workflow_utils';
 import { WorkflowsTriggersList } from '../../../widgets/worflows_triggers_list/worflows_triggers_list';
 import { WorkflowTags } from '../../../widgets/workflow_tags/workflow_tags';
+import type { WorkflowTriggerTab } from '../../run_workflow/ui/types';
 import { WorkflowExecuteModal } from '../../run_workflow/ui/workflow_execute_modal';
 import { WORKFLOWS_TABLE_PAGE_SIZE_OPTIONS } from '../constants';
 
@@ -91,7 +92,7 @@ export function WorkflowList({ search, setSearch, onCreateWorkflow }: WorkflowLi
   }, [refetch, selectedItems]);
 
   const handleRunWorkflow = useCallback(
-    (id: string, event: Record<string, unknown>, triggerTab?: 'manual' | 'alert' | 'index') => {
+    (id: string, event: Record<string, unknown>, triggerTab?: WorkflowTriggerTab) => {
       runWorkflow.mutate(
         { id, inputs: event, triggerTab },
         {
@@ -499,7 +500,7 @@ export function WorkflowList({ search, setSearch, onCreateWorkflow }: WorkflowLi
           definition={executeWorkflow.definition}
           workflowId={executeWorkflow.id}
           onClose={() => setExecuteWorkflow(null)}
-          onSubmit={(event) => handleRunWorkflow(executeWorkflow.id, event)}
+          onSubmit={(data, triggerTab) => handleRunWorkflow(executeWorkflow.id, data, triggerTab)}
         />
       )}
       {workflowToDelete && (
diff --git a/src/platform/plugins/shared/workflows_management/public/hooks/__mocks__/use_capabilities.ts b/src/platform/plugins/shared/workflows_management/public/hooks/__mocks__/use_capabilities.ts
new file mode 100644
index 0000000000000..011291fa1f3cf
--- /dev/null
+++ b/src/platform/plugins/shared/workflows_management/public/hooks/__mocks__/use_capabilities.ts
@@ -0,0 +1,21 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the "Elastic License
+ * 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side
+ * Public License v 1"; you may not use this file except in compliance with, at
+ * your election, the "Elastic License 2.0", the "GNU Affero General Public
+ * License v3.0 only", or the "Server Side Public License, v 1".
+ */
+
+import type { WorkflowsManagementCapabilities } from '../use_capabilities';
+
+export const mockCapabilities: WorkflowsManagementCapabilities = {
+  canCreateWorkflow: true,
+  canReadWorkflow: true,
+  canUpdateWorkflow: true,
+  canDeleteWorkflow: true,
+  canExecuteWorkflow: true,
+  canReadWorkflowExecution: true,
+  canCancelWorkflowExecution: true,
+};
+export const useCapabilities = jest.fn((): WorkflowsManagementCapabilities => mockCapabilities);
diff --git a/src/platform/plugins/shared/workflows_management/public/pages/workflow_detail/ui/workflow_detail_test_modal.test.tsx b/src/platform/plugins/shared/workflows_management/public/pages/workflow_detail/ui/workflow_detail_test_modal.test.tsx
index 4b7989267a91c..2b9257dc39cca 100644
--- a/src/platform/plugins/shared/workflows_management/public/pages/workflow_detail/ui/workflow_detail_test_modal.test.tsx
+++ b/src/platform/plugins/shared/workflows_management/public/pages/workflow_detail/ui/workflow_detail_test_modal.test.tsx
@@ -13,6 +13,7 @@ import { WorkflowDetailTestModal } from './workflow_detail_test_modal';
 import {
   selectEditorYaml,
   selectIsTestModalOpen,
+  selectReplayExecutionId,
   selectWorkflowDefinition,
   selectWorkflowId,
 } from '../../../entities/workflows/store';
@@ -44,6 +45,7 @@ jest.mock('../../../hooks/use_async_thunk', () => ({
 
 jest.mock('../../../entities/workflows/store/workflow_detail/selectors', () => ({
   selectIsTestModalOpen: jest.fn(),
+  selectReplayExecutionId: jest.fn(),
   selectWorkflowDefinition: jest.fn(),
   selectWorkflowId: jest.fn(),
   selectWorkflow: jest.fn(),
@@ -59,7 +61,7 @@ jest.mock('../../../features/run_workflow/ui/workflow_execute_modal', () => ({
   }: {
     definition: any;
     onClose: () => void;
-    onSubmit: (inputs: any) => void;
+    onSubmit: (inputs: any, triggerTab: string) => void;
   }) => (
     <div data-test-subj="workflow-execute-modal">
       <div data-test-subj="modal-definition">{JSON.stringify(definition)}</div>
@@ -69,7 +71,7 @@ jest.mock('../../../features/run_workflow/ui/workflow_execute_modal', () => ({
       <button
         type="button"
         data-test-subj="submit-modal"
-        onClick={() => onSubmit({ test: 'input' })}
+        onClick={() => onSubmit({ test: 'input' }, 'manual')}
       >
         {'Run'}
       </button>
@@ -103,6 +105,7 @@ describe('WorkflowDetailTestModal', () => {
     mockTestWorkflow = jest.fn();
 
     (selectIsTestModalOpen as unknown as jest.Mock).mockReturnValue(true);
+    (selectReplayExecutionId as unknown as jest.Mock).mockReturnValue(null);
     (selectWorkflowDefinition as unknown as jest.Mock).mockReturnValue(mockDefinition);
     (selectWorkflowId as unknown as jest.Mock).mockReturnValue(null);
     (selectEditorYaml as unknown as jest.Mock).mockReturnValue('');
@@ -199,7 +202,10 @@ describe('WorkflowDetailTestModal', () => {
     fireEvent.click(submitButton);
 
     await waitFor(() => {
-      expect(expectedCalledFunction).toHaveBeenCalledWith({ inputs: { test: 'input' } });
+      expect(expectedCalledFunction).toHaveBeenCalledWith({
+        inputs: { test: 'input' },
+        triggerTab: 'manual',
+      });
     });
   });
 
diff --git a/src/platform/plugins/shared/workflows_management/public/pages/workflow_detail/ui/workflow_detail_test_modal.tsx b/src/platform/plugins/shared/workflows_management/public/pages/workflow_detail/ui/workflow_detail_test_modal.tsx
index f553c31c18693..36c5fe271d6eb 100644
--- a/src/platform/plugins/shared/workflows_management/public/pages/workflow_detail/ui/workflow_detail_test_modal.tsx
+++ b/src/platform/plugins/shared/workflows_management/public/pages/workflow_detail/ui/workflow_detail_test_modal.tsx
@@ -13,11 +13,16 @@ import { i18n } from '@kbn/i18n';
 import {
   selectEditorYaml,
   selectIsTestModalOpen,
+  selectReplayExecutionId,
   selectWorkflowDefinition,
   selectWorkflowId,
 } from '../../../entities/workflows/store/workflow_detail/selectors';
-import { setIsTestModalOpen } from '../../../entities/workflows/store/workflow_detail/slice';
+import {
+  setIsTestModalOpen,
+  setReplayExecutionId,
+} from '../../../entities/workflows/store/workflow_detail/slice';
 import { testWorkflowThunk } from '../../../entities/workflows/store/workflow_detail/thunks/test_workflow_thunk';
+import type { WorkflowTriggerTab } from '../../../features/run_workflow/ui/types';
 import { WorkflowExecuteModal } from '../../../features/run_workflow/ui/workflow_execute_modal';
 import { useAsyncThunk } from '../../../hooks/use_async_thunk';
 import { useCapabilities } from '../../../hooks/use_capabilities';
@@ -32,6 +37,7 @@ export const WorkflowDetailTestModal = () => {
   const { setSelectedExecution } = useWorkflowUrlState();
 
   const isTestModalOpen = useSelector(selectIsTestModalOpen);
+  const replayExecutionId = useSelector(selectReplayExecutionId);
   const definition = useSelector(selectWorkflowDefinition);
   const workflowId = useSelector(selectWorkflowId);
   const yamlString = useSelector(selectEditorYaml);
@@ -39,7 +45,7 @@ export const WorkflowDetailTestModal = () => {
   const testWorkflow = useAsyncThunk(testWorkflowThunk);
 
   const handleRunWorkflow = useCallback(
-    async (inputs: Record<string, unknown>, triggerTab?: 'manual' | 'alert' | 'index') => {
+    async (inputs: Record<string, unknown>, triggerTab?: WorkflowTriggerTab) => {
       const executionId = await testWorkflow({ inputs, triggerTab });
 
       if (executionId) {
@@ -51,6 +57,7 @@ export const WorkflowDetailTestModal = () => {
 
   const closeModal = useCallback(() => {
     dispatch(setIsTestModalOpen(false));
+    dispatch(setReplayExecutionId(null));
   }, [dispatch]);
 
   useEffect(() => {
@@ -87,6 +94,7 @@ export const WorkflowDetailTestModal = () => {
       yamlString={yamlString}
       onClose={closeModal}
       onSubmit={handleRunWorkflow}
+      initialExecutionId={replayExecutionId ?? undefined}
     />
   );
 };
diff --git a/src/platform/plugins/shared/workflows_management/public/shared/ui/step_icons/get_step_icon_type.test.ts b/src/platform/plugins/shared/workflows_management/public/shared/ui/step_icons/get_step_icon_type.test.ts
new file mode 100644
index 0000000000000..680fb215199ff
--- /dev/null
+++ b/src/platform/plugins/shared/workflows_management/public/shared/ui/step_icons/get_step_icon_type.test.ts
@@ -0,0 +1,59 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the "Elastic License
+ * 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side
+ * Public License v 1"; you may not use this file except in compliance with, at
+ * your election, the "Elastic License 2.0", the "GNU Affero General Public
+ * License v3.0 only", or the "Server Side Public License, v 1".
+ */
+
+import { getStepIconType, getTriggerTypeIconType } from './get_step_icon_type';
+
+describe('getTriggerTypeIconType', () => {
+  it.each([
+    ['trigger_manual', 'play'],
+    ['trigger_alert', 'warning'],
+    ['trigger_document', 'document'],
+    ['trigger_scheduled', 'clock'],
+  ] as const)('should return "%s" icon for %s', (triggerType, expectedIcon) => {
+    expect(getTriggerTypeIconType(triggerType)).toBe(expectedIcon);
+  });
+
+  it('should return "info" for unknown trigger types', () => {
+    expect(getTriggerTypeIconType('trigger_unknown')).toBe('info');
+    expect(getTriggerTypeIconType('')).toBe('info');
+  });
+});
+
+describe('getStepIconType', () => {
+  it.each([
+    ['globe', 'http'],
+    ['console', 'console'],
+    ['tableOfContents', 'data.set'],
+    ['clock', 'wait'],
+    ['branch', 'if'],
+    ['tokenBoolean', 'if-branch'],
+    ['refresh', 'foreach'],
+    ['tokenNumber', 'foreach-iteration'],
+    ['email', 'email'],
+    ['logoSlack', 'slack'],
+    ['logoSlack', 'slack_api'],
+    ['sparkles', 'inference'],
+  ])('should return "%s" icon for the "%s" step type', (expectedIcon, nodeType) => {
+    expect(getStepIconType(nodeType)).toBe(expectedIcon);
+  });
+
+  it('should return "logoElasticsearch" for elasticsearch-prefixed types', () => {
+    expect(getStepIconType('elasticsearch.search')).toBe('logoElasticsearch');
+    expect(getStepIconType('elasticsearch.index')).toBe('logoElasticsearch');
+  });
+
+  it('should return "logoKibana" for kibana-prefixed types', () => {
+    expect(getStepIconType('kibana.alerting')).toBe('logoKibana');
+  });
+
+  it('should return "plugs" for unknown step types', () => {
+    expect(getStepIconType('custom_step')).toBe('plugs');
+    expect(getStepIconType('unknown')).toBe('plugs');
+  });
+});
diff --git a/src/platform/plugins/shared/workflows_management/public/shared/ui/step_icons/get_step_icon_type.ts b/src/platform/plugins/shared/workflows_management/public/shared/ui/step_icons/get_step_icon_type.ts
index 15a67e6aff70f..2bc5e2789bee7 100644
--- a/src/platform/plugins/shared/workflows_management/public/shared/ui/step_icons/get_step_icon_type.ts
+++ b/src/platform/plugins/shared/workflows_management/public/shared/ui/step_icons/get_step_icon_type.ts
@@ -9,27 +9,25 @@
 
 import type { EuiIconType } from '@elastic/eui/src/components/icon/icon';
 
-// eslint-disable-next-line complexity
-export const getStepIconType = (nodeType: string): EuiIconType => {
-  let iconType: EuiIconType = 'info';
-
-  let typeToMatch = nodeType;
-  if (nodeType.startsWith('trigger_')) {
-    typeToMatch = nodeType.replace('trigger_', '');
+export const getTriggerTypeIconType = (triggerType: string): EuiIconType => {
+  switch (triggerType) {
+    case 'trigger_manual':
+      return 'play';
+    case 'trigger_alert':
+      return 'warning';
+    case 'trigger_document':
+      return 'document';
+    case 'trigger_scheduled':
+      return 'clock';
+    default:
+      return 'info';
   }
+};
 
-  switch (typeToMatch) {
-    // triggers
-    case 'manual':
-      iconType = 'play';
-      break;
-    case 'alert':
-      iconType = 'warning';
-      break;
-    case 'scheduled':
-      iconType = 'clock';
-      break;
+export const getStepIconType = (nodeType: string): EuiIconType => {
+  let iconType: EuiIconType = 'info';
 
+  switch (nodeType) {
     // built-in node types
     case 'http':
       iconType = 'globe';
@@ -79,9 +77,9 @@ export const getStepIconType = (nodeType: string): EuiIconType => {
     // will be handled by in getStackConnectorIcon
 
     default:
-      if (typeToMatch.startsWith('elasticsearch')) {
+      if (nodeType.startsWith('elasticsearch')) {
         iconType = 'logoElasticsearch';
-      } else if (typeToMatch.startsWith('kibana')) {
+      } else if (nodeType.startsWith('kibana')) {
         iconType = 'logoKibana';
       } else {
         iconType = 'plugs';
diff --git a/src/platform/plugins/shared/workflows_management/public/shared/ui/step_icons/step_icon.tsx b/src/platform/plugins/shared/workflows_management/public/shared/ui/step_icons/step_icon.tsx
index 461c17a3dbfcf..6726053f699fc 100644
--- a/src/platform/plugins/shared/workflows_management/public/shared/ui/step_icons/step_icon.tsx
+++ b/src/platform/plugins/shared/workflows_management/public/shared/ui/step_icons/step_icon.tsx
@@ -14,7 +14,7 @@ import React, { Suspense } from 'react';
 import type { TypeRegistry } from '@kbn/alerts-ui-shared/lib';
 import type { ActionTypeModel } from '@kbn/triggers-actions-ui-plugin/public';
 import { ExecutionStatus } from '@kbn/workflows';
-import { getStepIconType } from './get_step_icon_type';
+import { getStepIconType, getTriggerTypeIconType } from './get_step_icon_type';
 import { useKibana } from '../../../hooks/use_kibana';
 import { getExecutionStatusColors, getExecutionStatusIcon } from '../status_badge';
 
@@ -43,25 +43,31 @@ export const StepIcon = React.memo(
       return <EuiBeacon size={14} color="warning" />;
     }
 
-    const actionTypeIcon = getActionTypeIcon(stepType, actionTypeRegistry);
-    if (actionTypeIcon) {
-      return (
-        <Suspense fallback={<EuiLoadingSpinner size="s" />}>
-          <EuiIcon type={actionTypeIcon} size="m" />
-        </Suspense>
-      );
-    }
+    let iconType: IconType;
+    if (stepType.startsWith('trigger_')) {
+      iconType = getTriggerTypeIconType(stepType);
+    } else {
+      const actionTypeIcon = getActionTypeIcon(stepType, actionTypeRegistry);
+      if (actionTypeIcon) {
+        return (
+          <Suspense fallback={<EuiLoadingSpinner size="s" />}>
+            <EuiIcon type={actionTypeIcon} size="m" aria-hidden={true} />
+          </Suspense>
+        );
+      }
 
-    const stepDefinition = workflowsExtensions.getStepDefinition(stepType);
-    if (stepDefinition?.icon) {
-      return (
-        <Suspense fallback={<EuiLoadingSpinner size="s" />}>
-          <EuiIcon type={stepDefinition.icon} size="m" />
-        </Suspense>
-      );
+      const stepDefinition = workflowsExtensions.getStepDefinition(stepType);
+      if (stepDefinition?.icon) {
+        return (
+          <Suspense fallback={<EuiLoadingSpinner size="s" />}>
+            <EuiIcon type={stepDefinition.icon} size="m" aria-hidden={true} />
+          </Suspense>
+        );
+      }
+
+      iconType = getStepIconType(stepType);
     }
 
-    const iconType = getStepIconType(stepType);
     if (iconType.startsWith('token')) {
       return (
         <EuiToken
@@ -100,6 +106,7 @@ export const StepIcon = React.memo(
         }
         onClick={onClick}
         {...rest}
+        aria-hidden={true}
       />
     );
   }