From 2495bb046c2e9e7bab67f4c2c58ae72871f37e8e Mon Sep 17 00:00:00 2001
From: Justin Gasper <jmgasper@gmail.com>
Date: Fri, 9 Oct 2026 18:06:48 +1100
Subject: [PATCH] PM-5573: Adjust active challenge timeline when switching AI
 only and AI gating

What was broken
On a launched challenge, switching the AI review mode between AI_ONLY and
AI_GATING did not change Timeline & Schedule. AI_GATING kept the AI Review
and Approval phases, and AI_ONLY kept AI Screening and the review phases.
After the first submission the whole AI review configuration was also
read-only, so the mode could not be switched at all.

Root cause
- The editor never asked challenge-api to move an ACTIVE challenge to the
  timeline matching its new mode. challenge-api did not do it for ACTIVE
  challenges either (fixed in challenge-api-v6 for PM-5573).
- The form also kept the old phases. Leaving AI_ONLY requires a manual
  reviewer, but the only phases offered were AI Review and Approval.
- AiReviewTab locked every field, and skipped autosave, whenever the
  challenge had submissions.

What was changed
- ReviewersField:
  - When a persisted AI config's mode no longer matches an ACTIVE
    challenge's timeline, it PATCHes the challenge reviewers right away so
    challenge-api moves the challenge to the matching template. It then
    loads the returned phases and timelineTemplateId into the form.
  - Both steps only happen before a review phase starts.
  - It passes canSwitchReviewMode to AiReviewTab until a review phase
    starts.
- AiReviewTab: with submissions, canSwitchReviewMode keeps the Review Mode
  select (AI_GATING / AI_ONLY) enabled and autosaving. This works for both
  manual and template configs. Every other setting stays locked, and the
  lock banner says the mode can still be switched.
- reviewers-field.utils: add hasAiOnlyTimelinePhases() and
  hasStartedReviewPhase().
- ChallengeEditorPage README documents the behaviour.

Added/updated tests
- ReviewersField.spec:
  - an active AI_ONLY challenge moves to the AI gating timeline, and the
    reverse
  - nothing is patched when the timeline already matches the mode
  - the mode is locked and the timeline kept once review starts
- AiReviewTab.spec:
  - only the review mode is editable and autosaves with submissions (manual
    and template configs)
  - the mode is locked once review starts
- reviewers-field.utils.spec: hasAiOnlyTimelinePhases and
  hasStartedReviewPhase.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../challenges/ChallengeEditorPage/README.md  |   2 +-
 .../ReviewersField/AiReviewTab.spec.tsx       | 145 ++++++++++++++
 .../components/ReviewersField/AiReviewTab.tsx |  36 +++-
 .../ReviewersField/ReviewersField.spec.tsx    | 185 +++++++++++++++++-
 .../ReviewersField/ReviewersField.tsx         |  82 +++++++-
 .../reviewers-field.utils.spec.ts             |  45 +++++
 .../ReviewersField/reviewers-field.utils.ts   |  38 ++++
 7 files changed, 519 insertions(+), 14 deletions(-)

diff --git a/src/apps/work/src/pages/challenges/ChallengeEditorPage/README.md b/src/apps/work/src/pages/challenges/ChallengeEditorPage/README.md
index e0a58d3ad..2f7c76c65 100644
--- a/src/apps/work/src/pages/challenges/ChallengeEditorPage/README.md
+++ b/src/apps/work/src/pages/challenges/ChallengeEditorPage/README.md
@@ -50,7 +50,7 @@ The form uses `challengeBasicInfoSchema` from `src/apps/work/src/lib/schemas/cha
 - `skills`: required unless billing account is listed in `SKILLS_OPTIONAL_BILLING_ACCOUNT_IDS`.
 - `reviewer`: optional for task challenges.
 - `reviewers`: when using `Save as Draft` from `NEW` status, non-task/non-marathon challenges must include reviewer coverage for configured review phases. If required phases are configured, each phase must have at least one member reviewer with a scorecard. The Screening and Checkpoint Screening configurations and scorecards remain required, but their Screener member assignments may be left empty until after launch. Design `Challenge` reviewers additionally leave the Checkpoint Review, Review, and Approval member assignments optional because the selected copilot is assigned to those private phases during save; other closed manual reviewer assignments remain required.
-- `AI review configuration`: templates and manual configs autosave separately once valid, switching a template-backed config to manual mode keeps its copied settings but clears the template link on save, and the AI tab becomes read-only after the challenge has submissions.
+- `AI review configuration`: templates and manual configs autosave separately once valid, switching a template-backed config to manual mode keeps its copied settings but clears the template link on save, and the AI tab becomes read-only after the challenge has submissions. The only exception is the review mode: it can still switch between AI_GATING and AI_ONLY (for manual and template configs) until a review phase (AI Screening, AI Review, Review, ...) starts. When an active challenge's mode no longer matches its timeline, the editor saves the reviewers right away so challenge-api moves the challenge to the matching timeline (AI Review and Approval for AI_ONLY, AI Screening and the review phases for AI_GATING), then loads the new phases into Timeline & Schedule.
 
 ## Autosave Behavior
 
diff --git a/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ReviewersField/AiReviewTab.spec.tsx b/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ReviewersField/AiReviewTab.spec.tsx
index 0de48113d..897480e1a 100644
--- a/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ReviewersField/AiReviewTab.spec.tsx
+++ b/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ReviewersField/AiReviewTab.spec.tsx
@@ -585,4 +585,149 @@ describe('AiReviewTab review mode options', () => {
         )
             .toBe(true)
     })
+
+    describe('with submissions', () => {
+        const lockedWorkflows = [
+            {
+                id: 'config-workflow-1',
+                isGating: false,
+                weightPercent: 100,
+                workflowId: 'workflow-1',
+            },
+        ]
+
+        /**
+         * Finds the Review Mode select, whose label also wraps the mode description.
+         */
+        async function findReviewModeSelect(): Promise<HTMLSelectElement> {
+            return (await screen.findByRole('option', { name: 'AI_ONLY' }))
+                .closest('select') as HTMLSelectElement
+        }
+
+        beforeEach(() => {
+            mockedFetchWorkflows.mockResolvedValue([
+                {
+                    id: 'workflow-1',
+                    name: 'Workflow 1',
+                },
+            ])
+            mockedUpdateAiReviewConfig.mockImplementation(async (_configId, input) => ({
+                ...baseConfiguration,
+                ...input,
+                id: 'config-1',
+            }))
+        })
+
+        it('keeps only the review mode editable until the review phase starts', async () => {
+            jest.useFakeTimers()
+            mockedFetchAiReviewConfigByChallenge.mockResolvedValueOnce({
+                ...baseConfiguration,
+                mode: 'AI_ONLY',
+                workflows: lockedWorkflows,
+            })
+
+            render(
+                <AiReviewTab
+                    canSwitchReviewMode
+                    challengeId='challenge-1'
+                    hasSubmissions
+                    reviewers={persistedAiReviewers}
+                />,
+            )
+
+            const reviewModeSelect = await findReviewModeSelect()
+
+            expect(reviewModeSelect.disabled)
+                .toBe(false)
+            expect((screen.getByRole('slider') as HTMLInputElement).disabled)
+                .toBe(true)
+            expect((screen.getByLabelText('AI Workflow') as HTMLSelectElement).disabled)
+                .toBe(true)
+            expect(screen.queryByRole('button', { name: 'Remove AI config' }))
+                .toBeNull()
+            expect(screen.getByText(/You can still switch the review mode/)).not.toBeNull()
+
+            fireEvent.change(reviewModeSelect, {
+                target: {
+                    value: 'AI_GATING',
+                },
+            })
+
+            await act(async () => {
+                jest.advanceTimersByTime(1600)
+            })
+
+            await waitFor(() => {
+                expect(mockedUpdateAiReviewConfig)
+                    .toHaveBeenCalledWith(
+                        'config-1',
+                        expect.objectContaining({
+                            minPassingThreshold: 75,
+                            mode: 'AI_GATING',
+                        }),
+                    )
+            })
+        })
+
+        it('lets template configs switch the review mode until the review phase starts', async () => {
+            jest.useFakeTimers()
+            mockedFetchAiReviewTemplates.mockResolvedValue([])
+            mockedFetchAiReviewConfigByChallenge.mockResolvedValueOnce({
+                ...baseConfiguration,
+                templateId: 'template-1',
+                workflows: lockedWorkflows,
+            })
+
+            render(
+                <AiReviewTab
+                    canSwitchReviewMode
+                    challengeId='challenge-1'
+                    hasSubmissions
+                    reviewers={persistedAiReviewers}
+                />,
+            )
+
+            fireEvent.change(await findReviewModeSelect(), {
+                target: {
+                    value: 'AI_ONLY',
+                },
+            })
+
+            await act(async () => {
+                jest.advanceTimersByTime(1600)
+            })
+
+            await waitFor(() => {
+                expect(mockedUpdateAiReviewConfig)
+                    .toHaveBeenCalledWith(
+                        'config-1',
+                        expect.objectContaining({
+                            mode: 'AI_ONLY',
+                            templateId: 'template-1',
+                        }),
+                    )
+            })
+        })
+
+        it('locks the review mode once the review phase has started', async () => {
+            mockedFetchAiReviewConfigByChallenge.mockResolvedValueOnce({
+                ...baseConfiguration,
+                workflows: lockedWorkflows,
+            })
+
+            render(
+                <AiReviewTab
+                    canSwitchReviewMode={false}
+                    challengeId='challenge-1'
+                    hasSubmissions
+                    reviewers={persistedAiReviewers}
+                />,
+            )
+
+            expect((await findReviewModeSelect()).disabled)
+                .toBe(true)
+            expect(screen.queryByText(/You can still switch the review mode/))
+                .toBeNull()
+        })
+    })
 })
diff --git a/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ReviewersField/AiReviewTab.tsx b/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ReviewersField/AiReviewTab.tsx
index d6a064b21..71eec5936 100644
--- a/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ReviewersField/AiReviewTab.tsx
+++ b/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ReviewersField/AiReviewTab.tsx
@@ -53,6 +53,11 @@ export interface AiReviewConfigSaveController {
 }
 
 interface AiReviewTabProps {
+    /**
+     * Keeps the review mode (AI_GATING / AI_ONLY) editable while `hasSubmissions` locks the
+     * rest of the configuration. The parent sets it until the challenge's review phase starts.
+     */
+    canSwitchReviewMode?: boolean
     challengeId?: string
     hasSubmissions?: boolean
     onConfigRemoved?: () => Promise<void> | void
@@ -89,6 +94,8 @@ interface ManualWorkflowEditorProps {
 }
 
 interface ReviewSettingsProps {
+    /** Keeps the review mode select enabled when `readOnly` locks the other settings. */
+    canChangeMode?: boolean
     configuration: AiReviewConfigurationDraft
     onUpdate: <K extends keyof AiReviewConfigurationDraft>(
         field: K,
@@ -418,7 +425,7 @@ const ReviewSettings: FC<ReviewSettingsProps> = (
                 <label className={styles.fieldGroup}>
                     <span>Review Mode</span>
                     <select
-                        disabled={props.readOnly}
+                        disabled={props.readOnly && props.canChangeMode !== true}
                         onChange={handleModeChange}
                         value={mode}
                     >
@@ -494,6 +501,9 @@ export const AiReviewTab: FC<AiReviewTabProps> = (
     const normalizedChallengeId = normalizeReviewerText(props.challengeId)
     const onConfigRemoved = props.onConfigRemoved
     const readOnly = props.hasSubmissions === true
+    // A locked configuration can still switch its review mode until the review phase starts.
+    const canSwitchReviewModeOnly = readOnly && props.canSwitchReviewMode === true
+    const isAutosaveLocked = readOnly && !canSwitchReviewModeOnly
     const onConfigPersisted = props.onConfigPersisted
     const onConfigSaveControllerReady = props.onConfigSaveControllerReady
     const onSelectedModeChange = props.onSelectedModeChange
@@ -1041,7 +1051,7 @@ export const AiReviewTab: FC<AiReviewTabProps> = (
     }, [configurationMode, selectedTrackName, selectedTypeName])
 
     const persistConfiguration = useCallback(async (): Promise<void> => {
-        if (!normalizedConfiguration || readOnly || validationErrors.length > 0) {
+        if (!normalizedConfiguration || isAutosaveLocked || validationErrors.length > 0) {
             return
         }
 
@@ -1075,7 +1085,7 @@ export const AiReviewTab: FC<AiReviewTabProps> = (
                 configSavePromiseRef.current = undefined
             }
         }
-    }, [configId, normalizedConfiguration, readOnly, validationErrors])
+    }, [configId, isAutosaveLocked, normalizedConfiguration, validationErrors])
 
     const flushPendingSave = useCallback(async (): Promise<void> => {
         if (configSavePromiseRef.current) {
@@ -1122,7 +1132,7 @@ export const AiReviewTab: FC<AiReviewTabProps> = (
     }, [flushPendingSave, onConfigSaveControllerReady])
 
     useEffect(() => {
-        if (!normalizedChallengeId || !configurationMode || !normalizedConfiguration || readOnly) {
+        if (!normalizedChallengeId || !configurationMode || !normalizedConfiguration || isAutosaveLocked) {
             return undefined
         }
 
@@ -1150,9 +1160,9 @@ export const AiReviewTab: FC<AiReviewTabProps> = (
     }, [
         configId,
         configurationMode,
+        isAutosaveLocked,
         normalizedChallengeId,
         normalizedConfiguration,
-        readOnly,
         validationErrors,
     ])
 
@@ -1182,6 +1192,10 @@ export const AiReviewTab: FC<AiReviewTabProps> = (
                 ? (
                     <div className={styles.infoBanner}>
                         AI review configuration is locked because this challenge already has submissions.
+                        {canSwitchReviewModeOnly
+                            ? ' You can still switch the review mode between AI_GATING and AI_ONLY '
+                                + 'until the review phase starts.'
+                            : undefined}
                     </div>
                 )
                 : undefined}
@@ -1295,6 +1309,17 @@ export const AiReviewTab: FC<AiReviewTabProps> = (
                                 : undefined}
                         </section>
 
+                        {canSwitchReviewModeOnly
+                            ? (
+                                <ReviewSettings
+                                    canChangeMode
+                                    configuration={configuration}
+                                    onUpdate={updateConfiguration}
+                                    readOnly
+                                />
+                            )
+                            : undefined}
+
                         <section className={styles.sectionCard}>
                             <div className={styles.sectionHeader}>
                                 <h3>Template Workflows</h3>
@@ -1332,6 +1357,7 @@ export const AiReviewTab: FC<AiReviewTabProps> = (
                         </div>
 
                         <ReviewSettings
+                            canChangeMode={canSwitchReviewModeOnly}
                             configuration={configuration}
                             onUpdate={updateConfiguration}
                             readOnly={readOnly}
diff --git a/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ReviewersField/ReviewersField.spec.tsx b/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ReviewersField/ReviewersField.spec.tsx
index 8a1894ffb..fb2cbb1b6 100644
--- a/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ReviewersField/ReviewersField.spec.tsx
+++ b/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ReviewersField/ReviewersField.spec.tsx
@@ -2,6 +2,7 @@
 import {
     render,
     screen,
+    waitFor,
 } from '@testing-library/react'
 import userEvent from '@testing-library/user-event'
 import {
@@ -60,6 +61,7 @@ jest.mock('./AiReviewTab', () => ({
     __esModule: true,
     default: function AiReviewTabMock(
         props: {
+            canSwitchReviewMode?: boolean
             hasSubmissions?: boolean
             onConfigRemoved?: () => Promise<void> | void
             onConfigPersisted?: (config: unknown) => void
@@ -107,6 +109,9 @@ jest.mock('./AiReviewTab', () => ({
                 {props.hasSubmissions
                     ? <div data-testid='ai-review-tab-read-only'>AI review locked</div>
                     : undefined}
+                {props.canSwitchReviewMode === false
+                    ? <div data-testid='ai-review-mode-locked'>AI review mode locked</div>
+                    : undefined}
                 <button
                     onClick={handleRemoveClick}
                     type='button'
@@ -159,21 +164,86 @@ interface TestHarnessProps {
     canConfigureFullReview?: boolean
     isReadOnly?: boolean
     numOfSubmissions?: number
+    phases?: ChallengeEditorFormData['phases']
     reviewers: Reviewer[]
     screenerOnly?: boolean
+    status?: string
+    timelineTemplateId?: string
+}
+
+const STARTED_PHASE = {
+    actualStartDate: '2026-10-01T00:00:00.000Z',
+    isOpen: true,
 }
+const ACTIVE_AI_ONLY_PHASES: ChallengeEditorFormData['phases'] = [
+    {
+        ...STARTED_PHASE,
+        id: 'challenge-phase-registration',
+        name: 'Registration',
+        phaseId: 'phase-registration',
+    },
+    {
+        ...STARTED_PHASE,
+        id: 'challenge-phase-submission',
+        name: 'Submission',
+        phaseId: 'phase-submission',
+    },
+    {
+        id: 'challenge-phase-ai-review',
+        name: 'AI Review',
+        phaseId: 'phase-ai-review',
+    },
+    {
+        id: 'challenge-phase-approval',
+        name: 'Approval',
+        phaseId: 'phase-approval',
+    },
+]
+const ACTIVE_AI_GATING_PHASES: ChallengeEditorFormData['phases'] = [
+    ACTIVE_AI_ONLY_PHASES[0],
+    ACTIVE_AI_ONLY_PHASES[1],
+    {
+        id: 'challenge-phase-ai-screening',
+        name: 'AI Screening',
+        phaseId: 'phase-ai-screening',
+    },
+    {
+        id: 'challenge-phase-review',
+        name: 'Review',
+        phaseId: 'phase-review',
+    },
+    {
+        id: 'challenge-phase-appeals',
+        name: 'Appeals',
+        phaseId: 'phase-appeals',
+    },
+]
+const AI_GATING_TIMELINE_CHALLENGE = {
+    phases: ACTIVE_AI_GATING_PHASES,
+    timelineTemplateId: 'default-timeline-template',
+} as Challenge
+const AI_ONLY_TIMELINE_CHALLENGE = {
+    phases: ACTIVE_AI_ONLY_PHASES,
+    timelineTemplateId: 'ai-only-timeline-template',
+} as Challenge
 
 const TestHarness = (props: TestHarnessProps): JSX.Element => {
     const formMethods = useForm<ChallengeEditorFormData>({
         defaultValues: {
             id: 'challenge-1',
             numOfSubmissions: props.numOfSubmissions,
-            phases: [],
+            phases: props.phases || [],
             reviewers: props.reviewers,
+            status: props.status,
+            timelineTemplateId: props.timelineTemplateId,
             trackId: 'track-id',
             typeId: 'type-id',
         },
     })
+    const formPhaseNames = (formMethods.watch('phases') || [])
+        .map(phase => phase.name)
+        .join(',')
+    const formTimelineTemplateId = formMethods.watch('timelineTemplateId')
     const reviewersField = (
         <ReviewersField
             canConfigureFullReview={props.canConfigureFullReview}
@@ -187,6 +257,8 @@ const TestHarness = (props: TestHarnessProps): JSX.Element => {
     return (
         <FormProvider {...formMethods}>
             {reviewersField}
+            <div data-testid='form-phases'>{formPhaseNames}</div>
+            <div data-testid='form-timeline-template'>{formTimelineTemplateId}</div>
             {reviewersFormError
                 ? <div data-testid='reviewers-form-error'>{reviewersFormError}</div>
                 : undefined}
@@ -420,6 +492,117 @@ describe('ReviewersField', () => {
         expect(screen.getByTestId('ai-review-tab-read-only')).not.toBeNull()
     })
 
+    it('moves an active AI only challenge to the AI gating timeline before review starts', async () => {
+        const user = userEvent.setup()
+        mockedPatchChallenge.mockResolvedValue(AI_GATING_TIMELINE_CHALLENGE)
+
+        render(
+            <TestHarness
+                numOfSubmissions={2}
+                phases={ACTIVE_AI_ONLY_PHASES}
+                reviewers={[]}
+                status='ACTIVE'
+                timelineTemplateId='ai-only-timeline-template'
+            />,
+        )
+
+        await user.click(screen.getByRole('tab', { name: 'AI Review (0)' }))
+        expect(screen.queryByTestId('ai-review-mode-locked'))
+            .toBeNull()
+        await user.click(screen.getByRole('button', { name: 'Persist AI config' }))
+
+        expect(mockedPatchChallenge)
+            .toHaveBeenCalledWith('challenge-1', {
+                reviewers: [],
+            })
+        await waitFor(() => {
+            expect(screen.getByTestId('form-phases').textContent)
+                .toBe('Registration,Submission,AI Screening,Review,Appeals')
+        })
+        expect(screen.getByTestId('form-timeline-template').textContent)
+            .toBe('default-timeline-template')
+    })
+
+    it('moves an active AI gating challenge to the AI only timeline before review starts', async () => {
+        const user = userEvent.setup()
+        mockedPatchChallenge.mockResolvedValue(AI_ONLY_TIMELINE_CHALLENGE)
+
+        render(
+            <TestHarness
+                numOfSubmissions={2}
+                phases={ACTIVE_AI_GATING_PHASES}
+                reviewers={[
+                    {
+                        isMemberReview: true,
+                        phaseId: 'phase-review',
+                        scorecardId: 'scorecard-1',
+                    },
+                ]}
+                status='ACTIVE'
+                timelineTemplateId='default-timeline-template'
+            />,
+        )
+
+        await user.click(screen.getByRole('tab', { name: 'AI Review (0)' }))
+        await user.click(screen.getByRole('button', { name: 'Persist AI only config' }))
+
+        expect(mockedPatchChallenge)
+            .toHaveBeenCalledWith('challenge-1', {
+                reviewers: [],
+            })
+        await waitFor(() => {
+            expect(screen.getByTestId('form-phases').textContent)
+                .toBe('Registration,Submission,AI Review,Approval')
+        })
+        expect(screen.getByTestId('form-timeline-template').textContent)
+            .toBe('ai-only-timeline-template')
+    })
+
+    it('does not patch an active challenge whose timeline already matches the review mode', async () => {
+        const user = userEvent.setup()
+
+        render(
+            <TestHarness
+                phases={ACTIVE_AI_ONLY_PHASES}
+                reviewers={[]}
+                status='ACTIVE'
+            />,
+        )
+
+        await user.click(screen.getByRole('tab', { name: 'AI Review (0)' }))
+        await user.click(screen.getByRole('button', { name: 'Persist AI only config' }))
+
+        expect(mockedPatchChallenge)
+            .not.toHaveBeenCalled()
+    })
+
+    it('locks the review mode and keeps the timeline once the review phase has started', async () => {
+        const user = userEvent.setup()
+        const reviewStartedPhases = ACTIVE_AI_ONLY_PHASES.map(phase => (
+            phase.name === 'AI Review'
+                ? { ...phase, ...STARTED_PHASE }
+                : phase
+        ))
+
+        render(
+            <TestHarness
+                numOfSubmissions={2}
+                phases={reviewStartedPhases}
+                reviewers={[]}
+                status='ACTIVE'
+            />,
+        )
+
+        await user.click(screen.getByRole('tab', { name: 'AI Review (0)' }))
+        expect(screen.getByTestId('ai-review-mode-locked')).not.toBeNull()
+        await user.click(screen.getByRole('button', { name: 'Persist AI config' }))
+
+        expect(mockedPatchChallenge)
+            .not.toHaveBeenCalled()
+        expect(screen.getByTestId('form-phases').textContent)
+            .toBe('Registration,Submission,AI Review,Approval')
+    })
+
     it('requires manual reviewer configuration when AI Review mode is AI GATING', async () => {
         const user = userEvent.setup()
 
diff --git a/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ReviewersField/ReviewersField.tsx b/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ReviewersField/ReviewersField.tsx
index bdcc124be..d5690fe8b 100644
--- a/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ReviewersField/ReviewersField.tsx
+++ b/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ReviewersField/ReviewersField.tsx
@@ -23,12 +23,17 @@ import * as services from '../../../../../lib/services'
 import {
     AiReviewConfig,
     AiReviewMode,
+    Challenge,
     ChallengeEditorFormData,
     Reviewer,
 } from '../../../../../lib/models'
+import { transformChallengeToFormData } from '../../../../../lib/utils/challenge-editor.utils'
+import { showErrorToast } from '../../../../../lib/utils/toast.utils'
 
 import {
     getReviewContextLockReason,
+    hasAiOnlyTimelinePhases,
+    hasStartedReviewPhase,
     isAiReviewer,
     syncAiConfigReviewers,
 } from './reviewers-field.utils'
@@ -76,6 +81,7 @@ export const ReviewersField: FC<ReviewersFieldProps> = (props: ReviewersFieldPro
     const humanTabRef = useRef<HTMLDivElement>(null)
     const aiTabRef = useRef<HTMLDivElement>(null)
     const contextTabRef = useRef<HTMLDivElement>(null)
+    const isSyncingScheduleRef = useRef<boolean>(false)
 
     const fetchAiReviewConfigByChallenge = services.fetchAiReviewConfigByChallenge ?? (async () => undefined)
     const patchChallenge = services.patchChallenge ?? (async () => undefined)
@@ -206,6 +212,10 @@ export const ReviewersField: FC<ReviewersFieldProps> = (props: ReviewersFieldPro
         () => Number(numOfSubmissions || 0) > 0,
         [numOfSubmissions],
     )
+    const hasReviewStarted = useMemo(
+        () => hasStartedReviewPhase(phases),
+        [phases],
+    )
     const reviewContextLockReason = useMemo(
         () => getReviewContextLockReason({
             hasSubmissions,
@@ -275,6 +285,57 @@ export const ReviewersField: FC<ReviewersFieldProps> = (props: ReviewersFieldPro
         [focusTab, handleTabChange],
     )
 
+    /**
+     * Loads the schedule persisted by challenge-api into the form, so the timeline and the
+     * manual reviewer phase options follow the timeline template challenge-api selected.
+     *
+     * @param savedChallenge challenge returned by the reviewer patch.
+     */
+    const applyPersistedSchedule = useCallback((savedChallenge: Challenge | undefined): void => {
+        const savedFormData = transformChallengeToFormData(savedChallenge)
+
+        if (!savedFormData.phases?.length) {
+            return
+        }
+
+        formContext.setValue('phases', savedFormData.phases, {
+            shouldDirty: true,
+            shouldValidate: true,
+        })
+        formContext.setValue('timelineTemplateId', savedFormData.timelineTemplateId, {
+            shouldDirty: true,
+        })
+    }, [formContext])
+    /**
+     * Persists the reviewers of an active challenge right after its AI review mode switches
+     * between AI_ONLY and AI_GATING. challenge-api then moves the challenge to the matching
+     * timeline template (AI Review for AI_ONLY, AI Screening plus the review phases for
+     * AI_GATING), and the new schedule is loaded into the form. The regular save cannot be
+     * used: leaving AI_ONLY requires a manual reviewer, which needs the Review phase first.
+     * Failures are reported with an error toast.
+     *
+     * @param nextReviewers reviewers to persist with the timeline switch.
+     */
+    const syncActiveScheduleWithReviewMode = useCallback((nextReviewers: Reviewer[]): void => {
+        if (!challengeId || isSyncingScheduleRef.current) {
+            return
+        }
+
+        isSyncingScheduleRef.current = true
+        patchChallenge(challengeId, {
+            reviewers: nextReviewers,
+        })
+            .then(applyPersistedSchedule)
+            .catch((error: unknown) => {
+                showErrorToast(error instanceof Error
+                    ? error.message
+                    : 'Failed to update the challenge timeline for the new AI review mode')
+            })
+            .finally(() => {
+                isSyncingScheduleRef.current = false
+            })
+    }, [applyPersistedSchedule, challengeId])
+
     const handleAiConfigPersisted = useCallback(
         (config: AiReviewConfig): void => {
             setAiReviewMode(config.mode)
@@ -291,16 +352,22 @@ export const ReviewersField: FC<ReviewersFieldProps> = (props: ReviewersFieldPro
                 nextReviewers = nextReviewers.filter(isAiReviewer)
             }
 
-            if (!hasReviewerChanges(currentReviewers, nextReviewers)) {
-                return
+            if (hasReviewerChanges(currentReviewers, nextReviewers)) {
+                formContext.setValue('reviewers', nextReviewers, {
+                    shouldDirty: true,
+                    shouldValidate: true,
+                })
             }
 
-            formContext.setValue('reviewers', nextReviewers, {
-                shouldDirty: true,
-                shouldValidate: true,
-            })
+            if (
+                challengeStatus === ChallengeStatus.Active
+                && !hasReviewStarted
+                && (config.mode === 'AI_ONLY') !== hasAiOnlyTimelinePhases(phases)
+            ) {
+                syncActiveScheduleWithReviewMode(nextReviewers)
+            }
         },
-        [formContext, phases],
+        [challengeStatus, formContext, hasReviewStarted, phases, syncActiveScheduleWithReviewMode],
     )
     const handleAiConfigRemoved = useCallback(async (): Promise<void> => {
         setAiReviewMode(undefined)
@@ -482,6 +549,7 @@ export const ReviewersField: FC<ReviewersFieldProps> = (props: ReviewersFieldPro
                                 role='tabpanel'
                             >
                                 <AiReviewTab
+                                    canSwitchReviewMode={!hasReviewStarted}
                                     challengeId={challengeId}
                                     hasSubmissions={hasSubmissions}
                                     onConfigPersisted={handleAiConfigPersisted}
diff --git a/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ReviewersField/reviewers-field.utils.spec.ts b/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ReviewersField/reviewers-field.utils.spec.ts
index 04369bff7..b22ea75b5 100644
--- a/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ReviewersField/reviewers-field.utils.spec.ts
+++ b/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ReviewersField/reviewers-field.utils.spec.ts
@@ -2,6 +2,8 @@ import {
     aiReviewConfigHasChanges,
     getAiReviewerPhaseId,
     getReviewContextLockReason,
+    hasAiOnlyTimelinePhases,
+    hasStartedReviewPhase,
     normalizeTrackForAiTemplates,
     syncAiConfigReviewers,
     validateAiReviewConfiguration,
@@ -203,6 +205,49 @@ describe('reviewers-field utils ai reviewer syncing', () => {
     })
 })
 
+describe('reviewers-field utils AI review mode timelines', () => {
+    it('detects schedules built from the AI Only timeline template', () => {
+        expect(hasAiOnlyTimelinePhases([
+            { name: 'Registration' },
+            { name: 'Submission' },
+            { name: ' ai review ' },
+            { name: 'Approval' },
+        ]))
+            .toBe(true)
+        expect(hasAiOnlyTimelinePhases([
+            { name: 'Registration' },
+            { name: 'Submission' },
+            { name: 'AI Screening' },
+            { name: 'Review' },
+        ]))
+            .toBe(false)
+        expect(hasAiOnlyTimelinePhases(undefined))
+            .toBe(false)
+    })
+
+    it('reports a review phase as started once it is open or has an actual start date', () => {
+        const submissionOpen = [
+            { actualStartDate: '2026-10-01T00:00:00.000Z', isOpen: true, name: 'Submission' },
+            { isOpen: false, name: 'AI Screening' },
+            { isOpen: false, name: 'Review' },
+        ]
+
+        expect(hasStartedReviewPhase(submissionOpen))
+            .toBe(false)
+        expect(hasStartedReviewPhase([
+            ...submissionOpen.slice(0, 1),
+            { isOpen: true, name: 'AI Screening' },
+        ]))
+            .toBe(true)
+        expect(hasStartedReviewPhase([
+            { actualStartDate: '2026-10-06T00:00:00.000Z', isOpen: false, name: 'AI Review' },
+        ]))
+            .toBe(true)
+        expect(hasStartedReviewPhase(undefined))
+            .toBe(false)
+    })
+})
+
 describe('reviewers-field utils review context locking', () => {
     const openSubmissionPhase = {
         isOpen: true,
diff --git a/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ReviewersField/reviewers-field.utils.ts b/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ReviewersField/reviewers-field.utils.ts
index efdabbb97..04f07ff1d 100644
--- a/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ReviewersField/reviewers-field.utils.ts
+++ b/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ReviewersField/reviewers-field.utils.ts
@@ -6,6 +6,10 @@ import {
     Reviewer,
     Workflow,
 } from '../../../../../lib/models'
+import {
+    AI_REVIEW_PHASE_NAME,
+    normalizePhaseName,
+} from '../ChallengeScheduleSection/ChallengeScheduleSection.utils'
 
 const TEMPLATE_TRACK_ALIASES: Record<string, string> = {
     DATA_SCIENCE: 'DATA_SCIENCE',
@@ -288,6 +292,40 @@ export function syncAiConfigReviewers(
     ]
 }
 
+/**
+ * Returns whether the schedule was built from the AI Only timeline template, which is the
+ * only template that contains an "AI Review" phase.
+ *
+ * @param phases challenge phases from the editor form.
+ * @returns `true` when an "AI Review" phase is present.
+ * @remarks Used by `ReviewersField` to tell whether an active challenge's timeline still
+ * matches its AI review mode after the mode switches between AI_ONLY and AI_GATING.
+ */
+export function hasAiOnlyTimelinePhases(phases: ChallengePhase[] | undefined): boolean {
+    return (Array.isArray(phases) ? phases : [])
+        .some(phase => normalizePhaseName(phase?.name) === normalizePhaseName(AI_REVIEW_PHASE_NAME))
+}
+
+/**
+ * Returns whether a review phase (AI Screening, AI Review, Review, Screening, ...) of the
+ * challenge is open or has already started.
+ *
+ * @param phases challenge phases from the editor form.
+ * @returns `true` when a phase whose name contains "review" or "screening" has started.
+ * @remarks `ReviewersField` uses it to stop AI_ONLY / AI_GATING switches once review starts,
+ * matching the review-api and challenge-api rules.
+ */
+export function hasStartedReviewPhase(phases: ChallengePhase[] | undefined): boolean {
+    return (Array.isArray(phases) ? phases : [])
+        .some(phase => {
+            const phaseName = normalizeReviewerText(phase?.name)
+                .toLowerCase()
+
+            return (phaseName.includes('review') || phaseName.includes('screening'))
+                && (phase.isOpen === true || !!normalizeReviewerText(phase.actualStartDate))
+        })
+}
+
 /**
  * Determines whether the challenge submission phase is over.
  */