feat(automl,autorag): add archive confirmation modal, tests, and docs

Add ArchiveRunModal with type-to-confirm pattern, link to Pipelines
archived runs view, and comprehensive test coverage including unit
tests, contract tests, OpenAPI specs, and API documentation.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: chrjones-rh

packages/automl/api/openapi/automl.yaml

@@ -979,6 +979,48 @@ paths:
         is in a retryable state (FAILED or CANCELED) before retrying it. This prevents users
         from retrying runs from other pipelines in the same namespace.
 
+  /api/v1/pipeline-runs/{runId}/archive:
+    summary: Archive a completed pipeline run
+    description: >-
+      Archives a pipeline run that is in a terminal state (SUCCEEDED, FAILED, or CANCELED).
+      The run must belong to one of the discovered AutoML pipelines in the namespace.
+      Archiving changes the run's storage_state from AVAILABLE to ARCHIVED, hiding it
+      from default list views. Archived runs can be restored from the Pipelines archived runs view.
+    post:
+      tags:
+        - PipelineOperation
+      security:
+        - Bearer: []
+      parameters:
+        - $ref: "#/components/parameters/namespace"
+        - name: runId
+          in: path
+          required: true
+          schema:
+            type: string
+          description: Unique identifier of the pipeline run to archive
+          example: "abc123-def456-ghi789"
+      responses:
+        "200":
+          description: Run archived successfully
+        "400":
+          $ref: "#/components/responses/BadRequest"
+        "401":
+          $ref: "#/components/responses/Unauthorized"
+        "404":
+          $ref: "#/components/responses/NotFound"
+        "500":
+          $ref: "#/components/responses/InternalServerError"
+        "503":
+          $ref: "#/components/responses/ServiceUnavailable"
+      operationId: archivePipelineRun
+      summary: Archive Pipeline Run
+      description: >-
+        Archives a completed, failed, or canceled AutoML pipeline run. The BFF validates that
+        the run belongs to one of the discovered AutoML managed pipelines in the namespace and
+        that it is in an archivable state (SUCCEEDED, FAILED, or CANCELED) before archiving it.
+        This prevents users from archiving runs from other pipelines in the same namespace.
+
 components:
   schemas:
     Config:

packages/automl/contract-tests/__tests__/testAutomlContract.test.ts

@@ -1244,5 +1244,47 @@ describe('AutoML API Contract Tests', () => {
         }
       });
     });
+
+    describe('Archive Pipeline Run', () => {
+      it('should archive a succeeded pipeline run', async () => {
+        const result = await apiClient.post(
+          '/api/v1/pipeline-runs/run-abc123-def456/archive?namespace=test-namespace',
+        );
+        expect(result.success).toBe(true);
+        if (result.success) {
+          expect(result.response.status).toBe(200);
+        }
+      });
+
+      it('should archive a failed pipeline run', async () => {
+        const result = await apiClient.post(
+          '/api/v1/pipeline-runs/run-mno345-pqr678/archive?namespace=test-namespace',
+        );
+        expect(result.success).toBe(true);
+        if (result.success) {
+          expect(result.response.status).toBe(200);
+        }
+      });
+
+      it('should return 400 when attempting to archive an active (RUNNING) run', async () => {
+        const result = await apiClient.post(
+          '/api/v1/pipeline-runs/run-ghi789-jkl012/archive?namespace=test-namespace',
+        );
+        expect(result.success).toBe(false);
+        if (!result.success) {
+          expect(result.error.status).toBe(400);
+        }
+      });
+
+      it('should return 404 for non-existent run ID', async () => {
+        const result = await apiClient.post(
+          '/api/v1/pipeline-runs/non-existent-run-id/archive?namespace=test-namespace',
+        );
+        expect(result.success).toBe(false);
+        if (!result.success) {
+          expect(result.error.status).toBe(404);
+        }
+      });
+    });
   });
 });

packages/automl/docs/pipeline-runs-api.md

@@ -669,6 +669,55 @@ Returns `200 OK` with an empty body on success.
 | `500 Internal Server Error` | Pipeline Server error or internal error |
 | `503 Service Unavailable` | Pipeline Server exists but is not ready |
 
+## Archive Pipeline Run
+
+### Endpoint
+
+```http
+POST /api/v1/pipeline-runs/{runId}/archive
+```
+
+Archives a pipeline run that is in a terminal state (SUCCEEDED, FAILED, or CANCELED). The run must belong to one of the discovered AutoML pipelines (timeseries or tabular) in the namespace. Archiving changes the run's `storage_state` from `AVAILABLE` to `ARCHIVED`, hiding it from the default list view. Archived runs can be restored from the Pipelines archived runs view.
+
+### Parameters
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `namespace` | query string | Yes | Kubernetes namespace where the Pipeline Server is deployed |
+| `runId` | path parameter | Yes | Unique identifier of the pipeline run to archive |
+
+### Security & Filtering
+
+This endpoint enforces the same ownership validation as the Terminate Run endpoint:
+
+- Fetches the run and validates it belongs to one of the discovered AutoML pipelines before archiving
+- Validates the run is in SUCCEEDED, FAILED, or CANCELED state before archiving
+- Returns `404 Not Found` if the run does not exist or belongs to a different pipeline
+- Returns `400 Bad Request` if the run is not in an archivable state
+- Prevents users from archiving runs from other pipelines in the same namespace
+
+### Request Example
+
+```bash
+curl -X POST "http://localhost:4003/api/v1/pipeline-runs/abc123-def456-ghi789/archive?namespace=my-namespace" \
+  -H "Authorization: Bearer <your-token>"
+```
+
+### Response Format
+
+Returns `200 OK` with an empty body on success.
+
+### Error Responses
+
+| Status | Condition |
+|--------|-----------|
+| `400 Bad Request` | Missing `runId` parameter, or run is not in SUCCEEDED, FAILED, or CANCELED state |
+| `401 Unauthorized` | Missing or invalid authentication |
+| `403 Forbidden` | User lacks permission to access pipeline servers in the namespace |
+| `404 Not Found` | Run not found, or run belongs to a different pipeline |
+| `500 Internal Server Error` | Pipeline Server error or internal error |
+| `503 Service Unavailable` | Pipeline Server exists but is not ready |
+
 ## Pipeline Discovery
 
 The API automatically discovers all managed AutoML pipelines (time-series and tabular) in the namespace and returns a merged view of their runs:

packages/automl/frontend/src/app/components/AutomlRunsTable/AutomlRunsTableRow.tsx

@@ -4,6 +4,7 @@ import { ActionsColumn, Td, Tr } from '@patternfly/react-table';
 import { Link } from 'react-router-dom';
 import RunStartTimestamp from '@odh-dashboard/internal/concepts/pipelines/content/tables/RunStartTimestamp';
 import type { PipelineRun } from '~/app/types';
+import ArchiveRunModal from '~/app/components/run-results/ArchiveRunModal';
 import StopRunModal from '~/app/components/run-results/StopRunModal';
 import { useAutomlRunActions } from '~/app/hooks/useAutomlRunActions';
 import { TASK_TYPE_LABELS } from '~/app/utilities/const';
@@ -67,6 +68,7 @@ const AutomlRunsTableRow: React.FC<AutomlRunsTableRowProps> = ({
   const taskType = getTaskType(run);
   const predictionTypeLabel = taskType ? (TASK_TYPE_LABELS[taskType] ?? taskType) : '—';
   const [isStopModalOpen, setIsStopModalOpen] = React.useState(false);
+  const [isArchiveModalOpen, setIsArchiveModalOpen] = React.useState(false);
   const { handleRetry, handleConfirmStop, handleArchive, isRetrying, isTerminating, isArchiving } =
     useAutomlRunActions(namespace, run.run_id, onActionComplete);
 
@@ -79,6 +81,11 @@ const AutomlRunsTableRow: React.FC<AutomlRunsTableRowProps> = ({
     setIsStopModalOpen(false);
   }, [handleConfirmStop]);
 
+  const handleConfirmArchive = React.useCallback(async () => {
+    await handleArchive();
+    setIsArchiveModalOpen(false);
+  }, [handleArchive]);
+
   const actions = React.useMemo(() => {
     const items: React.ComponentProps<typeof ActionsColumn>['items'] = [];
 
@@ -103,21 +110,13 @@ const AutomlRunsTableRow: React.FC<AutomlRunsTableRowProps> = ({
       }
       items.push({
         title: <span data-testid="archive-run-action">Archive</span>,
-        onClick: () => void handleArchive(),
+        onClick: () => setIsArchiveModalOpen(true),
         isDisabled: isArchiving,
       });
     }
 
     return items;
-  }, [
-    runTerminatable,
-    runRetryable,
-    runArchivable,
-    handleRetry,
-    handleArchive,
-    isRetrying,
-    isArchiving,
-  ]);
+  }, [runTerminatable, runRetryable, runArchivable, handleRetry, isRetrying, isArchiving]);
 
   return (
     <>
@@ -153,6 +152,14 @@ const AutomlRunsTableRow: React.FC<AutomlRunsTableRowProps> = ({
         isTerminating={isTerminating}
         runName={run.display_name}
       />
+      <ArchiveRunModal
+        isOpen={isArchiveModalOpen}
+        onClose={() => setIsArchiveModalOpen(false)}
+        onConfirm={handleConfirmArchive}
+        isArchiving={isArchiving}
+        runName={run.display_name}
+        namespace={namespace}
+      />
     </>
   );
 };

packages/automl/frontend/src/app/components/AutomlRunsTable/__tests__/AutomlRunsTableRow.spec.tsx

@@ -237,12 +237,23 @@ describe('AutomlRunsTableRow', () => {
       jest.clearAllMocks();
     });
 
-    it('should not show kebab menu for succeeded runs', () => {
+    it('should show archive action for succeeded runs', async () => {
       render(
         <MemoryRouter>
           <AutomlRunsTableRow run={{ ...mockRun, state: 'SUCCEEDED' }} namespace={mockNamespace} />
         </MemoryRouter>,
       );
+      const kebab = screen.getByRole('button', { name: 'Kebab toggle' });
+      await userEvent.click(kebab);
+      expect(screen.getByTestId('archive-run-action')).toBeInTheDocument();
+    });
+
+    it('should not show kebab menu for canceling runs', () => {
+      render(
+        <MemoryRouter>
+          <AutomlRunsTableRow run={{ ...mockRun, state: 'CANCELING' }} namespace={mockNamespace} />
+        </MemoryRouter>,
+      );
       expect(screen.queryByRole('button', { name: 'Kebab toggle' })).not.toBeInTheDocument();
     });
 

packages/automl/frontend/src/app/components/run-results/ArchiveRunModal.tsx

@@ -0,0 +1,94 @@
+import React from 'react';
+import { Link } from 'react-router-dom';
+import {
+  Button,
+  Flex,
+  FlexItem,
+  Modal,
+  ModalBody,
+  ModalFooter,
+  ModalHeader,
+  Stack,
+  StackItem,
+  TextInput,
+} from '@patternfly/react-core';
+
+type ArchiveRunModalProps = {
+  isOpen: boolean;
+  onClose: () => void;
+  onConfirm: () => void;
+  isArchiving: boolean;
+  runName?: string;
+  namespace: string;
+};
+
+const ArchiveRunModal: React.FC<ArchiveRunModalProps> = ({
+  isOpen,
+  onClose,
+  onConfirm,
+  isArchiving,
+  runName,
+  namespace,
+}) => {
+  const [confirmInputValue, setConfirmInputValue] = React.useState('');
+  const confirmMessage = runName ?? '';
+  const isDisabled = confirmInputValue.trim() !== confirmMessage || isArchiving;
+
+  const handleClose = React.useCallback(() => {
+    setConfirmInputValue('');
+    onClose();
+  }, [onClose]);
+
+  return (
+    <Modal variant="small" isOpen={isOpen} onClose={handleClose} data-testid="archive-run-modal">
+      <ModalHeader title="Archive AutoML optimization run?" titleIconVariant="warning" />
+      <ModalBody>
+        <Stack hasGutter>
+          <StackItem>
+            The run will be archived. It can be restored from the Pipelines{' '}
+            <Link to={`/develop-train/pipelines/runs/${namespace}/runs/archived`}>
+              archived runs
+            </Link>{' '}
+            view.
+          </StackItem>
+          <StackItem>
+            <Flex direction={{ default: 'column' }} spaceItems={{ default: 'spaceItemsSm' }}>
+              <FlexItem>
+                Type <strong>{confirmMessage}</strong> to confirm archiving:
+              </FlexItem>
+              <TextInput
+                id="confirm-archive-input"
+                data-testid="confirm-archive-input"
+                aria-label="confirm archive input"
+                value={confirmInputValue}
+                onChange={(_e, newValue) => setConfirmInputValue(newValue)}
+                onKeyDown={(event) => {
+                  if (event.key === 'Enter' && !isDisabled) {
+                    onConfirm();
+                  }
+                }}
+              />
+            </Flex>
+          </StackItem>
+        </Stack>
+      </ModalBody>
+      <ModalFooter>
+        <Button
+          variant="primary"
+          onClick={onConfirm}
+          isDisabled={isDisabled}
+          isLoading={isArchiving}
+          spinnerAriaValueText="Archiving run"
+          data-testid="confirm-archive-run-button"
+        >
+          Archive
+        </Button>
+        <Button variant="link" onClick={handleClose} isDisabled={isArchiving}>
+          Cancel
+        </Button>
+      </ModalFooter>
+    </Modal>
+  );
+};
+
+export default ArchiveRunModal;