From 3baab7acd6505aa3117146ce6efaab1df4866859 Mon Sep 17 00:00:00 2001
From: Justin Gasper <jmgasper@gmail.com>
Date: Wed, 12 Aug 2026 16:52:02 +1000
Subject: [PATCH 01/13] PM-5858: Require assignment before ticket closure

What was broken
Support Team members could close an unassigned ticket, and the closed-ticket detail did not identify who closed it.

Root cause
The close control checked only Support Team membership, and the UI contract omitted the closer ID already stored by the API.

What was changed
Disable closure unless the current Support Team user is assigned, accept the optional closer ID, and display the matching assignee handle with a stored-ID fallback.

Any added/updated tests
Updated TicketDetailPage coverage for unassigned and assigned closure access, closer-handle display, and legacy closer-ID fallback.
---
 src/apps/support/README.md                    |  3 +-
 .../support/src/lib/models/support.models.ts  |  1 +
 .../ticket-details/TicketDetailPage.spec.tsx  | 55 ++++++++++++++++++-
 .../pages/ticket-details/TicketDetailPage.tsx | 19 +++++++
 4 files changed, 75 insertions(+), 3 deletions(-)

diff --git a/src/apps/support/README.md b/src/apps/support/README.md
index eaad0a17d..ead5236ab 100644
--- a/src/apps/support/README.md
+++ b/src/apps/support/README.md
@@ -3,7 +3,8 @@
 The Support subapp lets authenticated Topcoder members open requests, follow
 their status, and reply to the Topcoder Support Team. Users with the exact
 `Topcoder Support Team` role can see all tickets, assign themselves, search
-closed tickets, reply to tickets assigned to them, and close resolved requests.
+closed tickets, and reply to or close resolved requests assigned to them.
+Closed ticket details identify the Support Team user who closed the request.
 
 ## Routes
 
diff --git a/src/apps/support/src/lib/models/support.models.ts b/src/apps/support/src/lib/models/support.models.ts
index 5c346295f..f0c94d64f 100644
--- a/src/apps/support/src/lib/models/support.models.ts
+++ b/src/apps/support/src/lib/models/support.models.ts
@@ -33,6 +33,7 @@ export interface SupportTicketSummary {
     status: SupportTicketStatus
     openedAt: string
     closedAt?: string
+    closedByUserId?: string
     updatedAt: string
     latestActivityAt: string
     responseCount: number
diff --git a/src/apps/support/src/pages/ticket-details/TicketDetailPage.spec.tsx b/src/apps/support/src/pages/ticket-details/TicketDetailPage.spec.tsx
index 66b321d20..9e69ac6a5 100644
--- a/src/apps/support/src/pages/ticket-details/TicketDetailPage.spec.tsx
+++ b/src/apps/support/src/pages/ticket-details/TicketDetailPage.spec.tsx
@@ -196,6 +196,49 @@ describe('TicketDetailPage reply access', () => {
             .toBeTruthy()
     })
 
+    it('identifies the support staff member who closed the ticket', () => {
+        mockUseSWR.mockReturnValue({
+            data: {
+                ...closedTicket,
+                assignees: [{
+                    assignedAt: '2026-08-07T00:30:00.000Z',
+                    handle: 'support-agent',
+                    userId: '99999',
+                }],
+                closedByUserId: '99999',
+            },
+            error: undefined,
+            isValidating: false,
+            mutate: mockMutate,
+        })
+
+        render(<TicketDetailPage />)
+
+        expect(screen.getByText((_content, element) => (
+            element?.tagName === 'P'
+            && element.textContent?.includes('Closed') === true
+            && element.textContent?.includes('by support-agent') === true
+        )))
+            .toBeTruthy()
+    })
+
+    it('falls back to the stored closer user ID when no assignee snapshot matches', () => {
+        mockUseSWR.mockReturnValue({
+            data: {
+                ...closedTicket,
+                closedByUserId: 'legacy-staff-1',
+            },
+            error: undefined,
+            isValidating: false,
+            mutate: mockMutate,
+        })
+
+        render(<TicketDetailPage />)
+
+        expect(screen.getByText('legacy-staff-1'))
+            .toBeTruthy()
+    })
+
     it('preserves freshly revalidated assignees when marking a ticket read completes', async () => {
         const markReadRequest = createDeferred<void>()
         mockedMarkRead.mockReturnValue(markReadRequest.promise)
@@ -242,7 +285,7 @@ describe('TicketDetailPage reply access', () => {
             .toBeUndefined()
     })
 
-    it('requires non-owner support staff to assign an open ticket before replying', () => {
+    it('requires non-owner support staff to assign an open ticket before replying or closing it', () => {
         mockProfile = {
             roles: ['Topcoder Support Team'],
             userId: 99999,
@@ -264,9 +307,13 @@ describe('TicketDetailPage reply access', () => {
             .toBeNull()
         expect(screen.getByText('Assign this ticket to yourself before replying.'))
             .toBeTruthy()
+        expect((screen.getByRole('button', {
+            name: 'Close support ticket',
+        }) as HTMLButtonElement).disabled)
+            .toBe(true)
     })
 
-    it('lets assigned support staff reply to an open ticket', () => {
+    it('lets assigned support staff reply to and close an open ticket', () => {
         mockProfile = {
             roles: ['Topcoder Support Team'],
             userId: 99999,
@@ -293,5 +340,9 @@ describe('TicketDetailPage reply access', () => {
             .toBeTruthy()
         expect(screen.queryByText('Assign this ticket to yourself before replying.'))
             .toBeNull()
+        expect((screen.getByRole('button', {
+            name: 'Close support ticket',
+        }) as HTMLButtonElement).disabled)
+            .toBe(false)
     })
 })
diff --git a/src/apps/support/src/pages/ticket-details/TicketDetailPage.tsx b/src/apps/support/src/pages/ticket-details/TicketDetailPage.tsx
index 4df066db3..8ac4bfeb5 100644
--- a/src/apps/support/src/pages/ticket-details/TicketDetailPage.tsx
+++ b/src/apps/support/src/pages/ticket-details/TicketDetailPage.tsx
@@ -106,6 +106,9 @@ export const TicketDetailPage: FC = () => {
         assignee => String(assignee.userId) === currentUserId,
     ))
     const closed = data.status === 'CLOSED'
+    const closedByAssignee = data.closedByUserId
+        ? data.assignees.find(assignee => String(assignee.userId) === String(data.closedByUserId))
+        : undefined
     const ticketOwner = Boolean(currentUserId && String(data.memberUserId) === currentUserId)
     const canReply = ticketOwner || (!closed && (!supportTeam || assignedToCurrentUser))
     const replyContext = `${data.id}-reply-${replyRevision}`
@@ -234,6 +237,21 @@ export const TicketDetailPage: FC = () => {
                             Closed
                             {' '}
                             {formatSupportDate(data.closedAt)}
+                            {data.closedByUserId && (
+                                <>
+                                    {' '}
+                                    by
+                                    {' '}
+                                    <span>
+                                        {closedByAssignee ? (
+                                            <MemberHandle
+                                                color={closedByAssignee.handleColor}
+                                                handle={closedByAssignee.handle}
+                                            />
+                                        ) : data.closedByUserId}
+                                    </span>
+                                </>
+                            )}
                         </p>
                     )}
                 </div>
@@ -247,6 +265,7 @@ export const TicketDetailPage: FC = () => {
                             size='md'
                         />
                         <Button
+                            disabled={updatingAssignment || !assignedToCurrentUser}
                             label='Close support ticket'
                             onClick={() => setConfirmClose(true)}
                             primary

From 0f9a4e76b96a6cbd57f646641bf2d883690edc5c Mon Sep 17 00:00:00 2001
From: Justin Gasper <jmgasper@gmail.com>
Date: Wed, 12 Aug 2026 17:11:24 +1000
Subject: [PATCH 02/13] PM-5861: Add totals to dashboard report tooltips

What was broken

Dashboard report tooltips listed each series value for a month but did not show the combined monthly total.

Root cause

The shared Highcharts configuration only defined the header and per-series rows. It had no formatter or footer that calculated a total, and stack totals would not cover the grouped Challenge Participation report.

What was changed

Extended the shared dashboard tooltip formatter to preserve the existing Highcharts content, sum every hovered series point, and append a comma-formatted Total row. Currency reports include the dollar prefix while count reports remain unit-free.

Any added/updated tests

Updated DashboardChart coverage for currency totals, stacked count totals, and grouped count totals. All 13 Reports suites (54 tests), lint, and the production build pass. The full repository test command was run twice and retains 18 unrelated failures in existing Work, Wallet Admin, Profiles, and Engagements tests.
---
 .../pages/dashboards/DashboardChart.spec.tsx  | 90 ++++++++++++++++---
 .../src/pages/dashboards/DashboardChart.tsx   | 25 +++++-
 2 files changed, 101 insertions(+), 14 deletions(-)

diff --git a/src/apps/reports/src/pages/dashboards/DashboardChart.spec.tsx b/src/apps/reports/src/pages/dashboards/DashboardChart.spec.tsx
index bc9eb3227..5d26cade2 100644
--- a/src/apps/reports/src/pages/dashboards/DashboardChart.spec.tsx
+++ b/src/apps/reports/src/pages/dashboards/DashboardChart.spec.tsx
@@ -8,21 +8,23 @@ import {
 import Highcharts from 'highcharts'
 
 import {
+    ChallengeParticipationDashboard,
     MemberPaymentByCustomerDashboard,
     NewSignupsDashboard,
 } from '../../lib/services'
 
 import { DashboardChart } from './DashboardChart'
 
+let chartOptions: Highcharts.Options
+
 jest.mock('highcharts-react-official', () => ({
     __esModule: true,
-    default: (props: {
-        options: {
-            series?: Array<{ data?: number[]; name?: string }>
-            tooltip?: { pointFormat?: string }
-        }
-    }): JSX.Element => {
-        const series = props.options.series || []
+    default: (props: { options: Highcharts.Options }): JSX.Element => {
+        chartOptions = props.options
+        const series = props.options.series as Array<{
+            data?: number[]
+            name?: string
+        }> || []
 
         return (
             <div
@@ -30,7 +32,6 @@ jest.mock('highcharts-react-official', () => ({
                 data-series-names={series.map(item => item.name)
                     .join('|')}
                 data-testid='dashboard-chart'
-                data-tooltip={props.options.tooltip?.pointFormat}
             />
         )
     },
@@ -96,10 +97,61 @@ const signupResponse: NewSignupsDashboard = {
     },
 }
 
+const challengeParticipationResponse: ChallengeParticipationDashboard = {
+    dashboard: 'challenge-participation',
+    endDate: '2026-02-01T00:00:00.000Z',
+    months: [{
+        month: '2026-01-01',
+        registrants: 120,
+        submitters: 75,
+    }],
+    startDate: '2026-01-01T00:00:00.000Z',
+    summary: {
+        peakMonth: '2026-01-01',
+        peakMonthRegistrants: 120,
+        submissionRate: 62.5,
+        totalUniqueRegistrants: 120,
+        totalUniqueSubmitters: 75,
+    },
+}
 const pointValueToken = '{point.y:,.0f}'
 const countTooltipValue = `<b>${pointValueToken}</b>`
 const currencyTooltipValue = `<b>$${pointValueToken}</b>`
 
+/**
+ * Invokes the tooltip formatter captured from the rendered chart.
+ *
+ * Tests use this helper to verify totals independently of Highcharts' DOM renderer.
+ *
+ * @param values Hovered series values for one month.
+ * @returns The formatter's tooltip HTML as one string.
+ * @throws Error when the chart has no formatter or it returns no HTML.
+ */
+function formatTooltip(values: number[]): string {
+    const formatter = chartOptions.tooltip?.formatter
+    if (!formatter) {
+        throw new Error('Tooltip formatter is missing')
+    }
+
+    const context = {
+        points: values.map(y => ({ y })),
+    } as unknown as Highcharts.TooltipFormatterContextObject
+    const tooltip = {
+        defaultFormatter: () => ['<strong>Jan ’26</strong><br/>', 'series rows'],
+    } as unknown as Highcharts.Tooltip
+    const result = formatter.call(context, tooltip)
+
+    if (typeof result === 'string') {
+        return result
+    }
+
+    if (Array.isArray(result)) {
+        return result.join('')
+    }
+
+    throw new Error('Tooltip formatter did not return HTML')
+}
+
 describe('DashboardChart', () => {
     it('formats tooltip thousands with commas', () => {
         expect(Highcharts.getOptions().lang?.thousandsSep)
@@ -126,8 +178,10 @@ describe('DashboardChart', () => {
                 'data-series-data',
                 '[[125000,140000],[80000,0],[20000,25000]]',
             )
-        expect(chart.getAttribute('data-tooltip'))
+        expect(chartOptions.tooltip?.pointFormat)
             .toContain(currencyTooltipValue)
+        expect(formatTooltip([125_000, 80_000, 20_000]))
+            .toContain('Total: <b>$225,000</b>')
         expect(within(table)
             .getByRole('columnheader', { name: 'Customer A' }))
             .toBeInTheDocument()
@@ -142,20 +196,30 @@ describe('DashboardChart', () => {
             .toBeInTheDocument()
     })
 
-    it('keeps existing count dashboards unit-free', () => {
+    it('keeps count dashboard tooltips unit-free and adds their total', () => {
         render(<DashboardChart response={signupResponse} />)
 
-        const chart = screen.getByTestId('dashboard-chart')
         const table = screen.getByRole('table', {
             name: 'New Signups by Month monthly data',
         })
 
-        expect(chart.getAttribute('data-tooltip'))
+        expect(chartOptions.tooltip?.pointFormat)
             .toContain(countTooltipValue)
-        expect(chart.getAttribute('data-tooltip'))
+        expect(chartOptions.tooltip?.pointFormat)
             .not.toContain(currencyTooltipValue)
+        expect(formatTooltip([90, 10]))
+            .toContain('Total: <b>100</b>')
+        expect(formatTooltip([90, 10]))
+            .not.toContain('$100')
         expect(within(table)
             .getByRole('cell', { name: '90' }))
             .toBeInTheDocument()
     })
+
+    it('adds a total to grouped report tooltips', () => {
+        render(<DashboardChart response={challengeParticipationResponse} />)
+
+        expect(formatTooltip([120, 75]))
+            .toContain('Total: <b>195</b>')
+    })
 })
diff --git a/src/apps/reports/src/pages/dashboards/DashboardChart.tsx b/src/apps/reports/src/pages/dashboards/DashboardChart.tsx
index 54182e43a..eeeab09db 100644
--- a/src/apps/reports/src/pages/dashboards/DashboardChart.tsx
+++ b/src/apps/reports/src/pages/dashboards/DashboardChart.tsx
@@ -50,7 +50,7 @@ function getSeriesValue(month: DashboardMonth, key: string): number {
  *
  * @param props Dashboard response and compact-card presentation flag.
  * @returns A stacked or grouped column chart with month categories along the
- * bottom axis and an accessible monthly data table.
+ * bottom axis, monthly tooltip totals, and an accessible monthly data table.
  * @throws Does not throw. Invalid or absent point values are rendered as zero.
  */
 export const DashboardChart: FC<DashboardChartProps> = props => {
@@ -119,6 +119,29 @@ export const DashboardChart: FC<DashboardChartProps> = props => {
             text: undefined,
         },
         tooltip: {
+            /**
+             * Appends the hovered month's total to Highcharts' shared tooltip.
+             *
+             * Highcharts invokes this callback for card and detail charts.
+             *
+             * @param tooltip Highcharts tooltip used to render the existing rows.
+             * @returns The default tooltip content followed by the formatted total.
+             * @throws Does not throw for the normalized chart-series values.
+             */
+            formatter(tooltip: Highcharts.Tooltip) {
+                // Highcharts supplies the shared tooltip context through `this`.
+                // eslint-disable-next-line react/no-this-in-sfc
+                const points = this.points || [this]
+                const total = points.reduce((sum, point) => sum + (point.y ?? 0), 0)
+                // eslint-disable-next-line react/no-this-in-sfc
+                const content = tooltip.defaultFormatter.call(this, tooltip)
+                const totalRow = `Total: <b>${isCurrency ? '$' : ''}`
+                    + `${Highcharts.numberFormat(total, 0)}</b>`
+
+                return Array.isArray(content)
+                    ? [...content, totalRow]
+                    : `${content}${totalRow}`
+            },
             headerFormat: '<strong>{point.key}</strong><br/>',
             pointFormat: '<span style="color:{series.color}">●</span> '
                 + `{series.name}: <b>${isCurrency ? '$' : ''}{point.y:,.0f}</b><br/>`,

From c54f074cae45e271e842be1f7ba0dbb8ada93772 Mon Sep 17 00:00:00 2001
From: Justin Gasper <jmgasper@gmail.com>
Date: Wed, 12 Aug 2026 18:20:37 +1000
Subject: [PATCH 03/13] PM-5755: Simplify design screener assignment

What was broken

Copilot-only users editing Design Challenges saw the complete review configuration and had to assign checkpoint and final screeners independently.

Root cause

The Review section did not distinguish copilot-only Design Challenge editing from admin and manager configuration, and each screening reviewer synchronized only its own resource role.

What was changed

Show a single Screener selector for copilot-only Design Challenges while leaving the full interface for administrators and managers. Synchronize the selected member across Checkpoint Screener and Screener resources, preserve hidden reviewer defaults, and guard replacement, clearing, legacy assignments, request failures, and overlapping updates.

Any added/updated tests

Added coverage for role and challenge-type gating, simplified rendering, two-round and one-round assignment, replacement and clearing, legacy handle-only resources, fetch failures, in-flight locking, and preservation of reviewer configuration.
---
 .../challenges/ChallengeEditorPage/README.md  |   4 +-
 .../components/ChallengeEditorForm.spec.tsx   | 131 +++-
 .../components/ChallengeEditorForm.tsx        |  10 +-
 .../ReviewersField/HumanReviewTab.spec.tsx    | 612 +++++++++++++++++-
 .../ReviewersField/HumanReviewTab.tsx         | 492 +++++++++++++-
 .../ReviewersField/ReviewersField.module.scss |   4 +
 .../ReviewersField/ReviewersField.spec.tsx    |  42 +-
 .../ReviewersField/ReviewersField.tsx         |  17 +-
 8 files changed, 1277 insertions(+), 35 deletions(-)

diff --git a/src/apps/work/src/pages/challenges/ChallengeEditorPage/README.md b/src/apps/work/src/pages/challenges/ChallengeEditorPage/README.md
index 4f38f5fdf..30438c767 100644
--- a/src/apps/work/src/pages/challenges/ChallengeEditorPage/README.md
+++ b/src/apps/work/src/pages/challenges/ChallengeEditorPage/README.md
@@ -23,7 +23,7 @@
   payload is available, so the create route can expand to the full editor immediately after the
   initial draft is created.
 - `components/*Field.tsx`: field-level components for each challenge section.
-- `components/ReviewersField/*`: tabbed human/AI review configuration. Human reviewers stay on the challenge form, while AI reviewer configs load/save through the review API and sync saved AI workflows back into the challenge `reviewers` array. Existing AI configs are reloaded once per saved challenge even if the challenge payload is temporarily missing synced AI reviewer rows, while still avoiding empty-config lookups for unsaved challenges, ordinary parent rerenders in edit mode, and same-session re-fetches right after a config is intentionally removed. Removing an AI config also detaches the synced AI workflow reviewers from the challenge. In read-only view mode the tab switcher remains clickable so users can inspect AI config details inside the disabled challenge form, and the review summary surfaces the human-review table, AI workflow details, resolved scorecard names, review flow, and estimated reviewer cost without requiring edits. Repeated human-review rows that share the same resource role now consume persisted challenge-resource assignments in row order so every assigned reviewer still appears once in the summary, and mixed legacy resource layouts continue into the generic `Reviewer` fallback pool when a phase-specific role runs out of persisted assignments. The editor hydration, editable tab, summary, and post-save reset now tolerate persisted resource rows that only expose role names, member handles, or member ids instead of the full modern payload shape, so refreshed drafts and newly saved drafts reopen with the saved reviewer assignments intact. Initial persisted-resource hydration also keeps running while the form is still in its mount-time normalization window, so internal dirty flags from compatibility fields do not block restored copilot or reviewer assignments after a full refresh. The AI-gating failure path keeps the locked state grouped under the gate so the diagram matches the legacy work-manager layout, including `AI_GATING` configs whose workflows do not explicitly mark `isGating`. On narrow screens the review-flow diagram switches to a compact portrait branch: submission stays full width, the `AI Gate` and `Locked` states sit side by side as narrower cards, the `< threshold` connector sits between those two cards, and the human-review path continues only from the gate column. When AI reviewers exist without a persisted AI screening phase, the schedule editor injects a virtual `AI Screening` row after submission phases. This `Review` section is hidden for `Task` and `Marathon Match` challenges because those flows use dedicated reviewer assignment UIs.
+- `components/ReviewersField/*`: tabbed human/AI review configuration. Copilot-only users editing Design `Challenge` types see one Screener selector that synchronizes the selected member across final Screening and, for two-round challenges, Checkpoint Screening while preserving all hidden phase, scorecard, and reviewer defaults; admins and managers retain the full interface. Human reviewers stay on the challenge form, while AI reviewer configs load/save through the review API and sync saved AI workflows back into the challenge `reviewers` array. Existing AI configs are reloaded once per saved challenge even if the challenge payload is temporarily missing synced AI reviewer rows, while still avoiding empty-config lookups for unsaved challenges, ordinary parent rerenders in edit mode, and same-session re-fetches right after a config is intentionally removed. Removing an AI config also detaches the synced AI workflow reviewers from the challenge. In read-only view mode the tab switcher remains clickable so users can inspect AI config details inside the disabled challenge form, and the review summary surfaces the human-review table, AI workflow details, resolved scorecard names, review flow, and estimated reviewer cost without requiring edits. Repeated human-review rows that share the same resource role now consume persisted challenge-resource assignments in row order so every assigned reviewer still appears once in the summary, and mixed legacy resource layouts continue into the generic `Reviewer` fallback pool when a phase-specific role runs out of persisted assignments. The editor hydration, editable tab, summary, and post-save reset now tolerate persisted resource rows that only expose role names, member handles, or member ids instead of the full modern payload shape, so refreshed drafts and newly saved drafts reopen with the saved reviewer assignments intact. Initial persisted-resource hydration also keeps running while the form is still in its mount-time normalization window, so internal dirty flags from compatibility fields do not block restored copilot or reviewer assignments after a full refresh. The AI-gating failure path keeps the locked state grouped under the gate so the diagram matches the legacy work-manager layout, including `AI_GATING` configs whose workflows do not explicitly mark `isGating`. On narrow screens the review-flow diagram switches to a compact portrait branch: submission stays full width, the `AI Gate` and `Locked` states sit side by side as narrower cards, the `< threshold` connector sits between those two cards, and the human-review path continues only from the gate column. When AI reviewers exist without a persisted AI screening phase, the schedule editor injects a virtual `AI Screening` row after submission phases. This `Review` section is hidden for `Task` and `Marathon Match` challenges because those flows use dedicated reviewer assignment UIs.
 - `ChallengeEditorPage.module.scss` and `components/ChallengeEditorForm.module.scss`: page and form layout styling, including the grouped `Prizes & Billing` layout that keeps the challenge-prizes and copilot-fee inputs at fixed widths on larger screens, preserves whitespace to the right, and moves the billing summary underneath them.
 
 ## Validation Rules
@@ -80,7 +80,7 @@ The form uses `challengeBasicInfoSchema` from `src/apps/work/src/lib/schemas/cha
   from `is_test_challenge`, and explicitly persists metadata value `true` or `false`. Test
   challenges do not generate payments, and authorized modifiers can delete them after they reach
   a completed or cancelled status.
-- `ReviewersField`: hidden for `Task` and `Marathon Match` challenges because manual reviewer assignment is handled elsewhere. On the human-review tab, each manual reviewer card keeps the legacy review-type dropdown, backfills missing legacy review-type values from the matching default reviewer or iterative-review phase fallback, and each manual reviewer phase selector hides registration/submission phases and any phase already assigned on another manual reviewer card while preserving the card's current selection. When default reviewer metadata is missing, stale, or already covered by existing rows, `Add reviewer` starts from the next unassigned selectable reviewer phase, preferring review phases before approval or screening phases, so single-round Design schedules add the Approver row instead of a registration/submission or duplicate reviewer row. Manual reviewer counts are capped before rendering member assignment controls so closed public opportunities cannot create an unbounded number of member selectors. Design challenge manual reviewers always keep the public review opportunity checkbox disabled and unchecked. Standard Screening member selectors remain available but are optional so a copilot can assign the Screener after launch.
+- `ReviewersField`: hidden for `Task` and `Marathon Match` challenges because manual reviewer assignment is handled elsewhere. Copilot-only Design Challenge editing exposes only the shared Screener selector; selecting, replacing, or clearing it updates both the `Screener` and any `Checkpoint Screener` challenge resources. On the full human-review tab, each manual reviewer card keeps the legacy review-type dropdown, backfills missing legacy review-type values from the matching default reviewer or iterative-review phase fallback, and each manual reviewer phase selector hides registration/submission phases and any phase already assigned on another manual reviewer card while preserving the card's current selection. When default reviewer metadata is missing, stale, or already covered by existing rows, `Add reviewer` starts from the next unassigned selectable reviewer phase, preferring review phases before approval or screening phases, so single-round Design schedules add the Approver row instead of a registration/submission or duplicate reviewer row. Manual reviewer counts are capped before rendering member assignment controls so closed public opportunities cannot create an unbounded number of member selectors. Design challenge manual reviewers always keep the public review opportunity checkbox disabled and unchecked. Standard Screening member selectors remain available but are optional so a copilot can assign the Screener after launch.
 - `Submission Settings`: shown for Design `Challenge` and Design `First2Finish` types, and contains the final-deliverables, stock-art, and submission-limit compatibility fields.
 - `RegisteredMemberDownloadField`: shown in Advanced Options for every created challenge type. The radio group persists `allowAllRegistrantsToDownloadWinningSubmissions` as the exact string `true` for all challenge registrants or `false` for passing submitters only. New Development challenges default to passing submitters; other new challenges, including Design, default to all registrants. Existing challenges without the metadata retain passing-submitter-only access.
 - `FinalDeliverablesField`: design-challenge file-type editor that persists the legacy `fileTypes` metadata payload used on challenge draft pages.
diff --git a/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ChallengeEditorForm.spec.tsx b/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ChallengeEditorForm.spec.tsx
index 19a740abf..2f735e926 100644
--- a/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ChallengeEditorForm.spec.tsx
+++ b/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ChallengeEditorForm.spec.tsx
@@ -684,7 +684,10 @@ jest.mock('./ReviewCostField', () => ({
     ReviewCostField: () => <></>,
 }))
 jest.mock('./ReviewersField', () => ({
-    ReviewersField: (props: { isReadOnly?: boolean }) => {
+    ReviewersField: (props: {
+        isReadOnly?: boolean
+        screenerOnly?: boolean
+    }) => {
         const reactHookForm: typeof import('react-hook-form') = jest.requireActual('react-hook-form')
         const reviewers = reactHookForm.useWatch({
             control: reactHookForm.useFormContext().control,
@@ -695,6 +698,7 @@ jest.mock('./ReviewersField', () => ({
             <div
                 data-read-only={props.isReadOnly === true ? 'true' : 'false'}
                 data-reviewers={JSON.stringify(reviewers || [])}
+                data-screener-only={props.screenerOnly === true ? 'true' : 'false'}
                 data-testid='reviewers-field'
             >
                 Reviewers Field
@@ -3058,6 +3062,131 @@ describe('ChallengeEditorForm', () => {
             .toBeNull()
     })
 
+    it('uses the simplified screener review for a copilot editing a Design Challenge', () => {
+        mockedUseFetchChallengeTracks.mockReturnValue({
+            isLoading: false,
+            tracks: [{
+                id: 'design-track-id',
+                name: 'Design',
+                track: 'DESIGN',
+            }],
+        })
+        mockedUseFetchChallengeTypes.mockReturnValue({
+            challengeTypes: [{
+                abbreviation: 'CH',
+                id: 'design-challenge-type-id',
+                name: 'Challenge',
+            }],
+            isLoading: false,
+        })
+
+        render(
+            <MemoryRouter>
+                <WorkAppContext.Provider value={copilotContextValue}>
+                    <ChallengeEditorForm challenge={designChallengeWithDeferredScreener} />
+                </WorkAppContext.Provider>
+            </MemoryRouter>,
+        )
+
+        expect(screen.getByTestId('reviewers-field'))
+            .toHaveAttribute('data-screener-only', 'true')
+    })
+
+    it('uses persisted Design Challenge metadata for the copilot review gate', () => {
+        mockedUseFetchChallengeTracks.mockReturnValue({
+            isLoading: false,
+            tracks: [],
+        })
+        mockedUseFetchChallengeTypes.mockReturnValue({
+            challengeTypes: [],
+            isLoading: false,
+        })
+
+        render(
+            <MemoryRouter>
+                <WorkAppContext.Provider value={copilotContextValue}>
+                    <ChallengeEditorForm
+                        challenge={{
+                            ...designChallengeWithDeferredScreener,
+                            track: {
+                                abbreviation: 'DESIGN',
+                                name: 'Design',
+                            },
+                        }}
+                    />
+                </WorkAppContext.Provider>
+            </MemoryRouter>,
+        )
+
+        expect(screen.getByTestId('reviewers-field'))
+            .toHaveAttribute('data-screener-only', 'true')
+    })
+
+    it('keeps the full review configuration for an admin editing a Design Challenge', () => {
+        mockedUseFetchChallengeTracks.mockReturnValue({
+            isLoading: false,
+            tracks: [{
+                id: 'design-track-id',
+                name: 'Design',
+                track: 'DESIGN',
+            }],
+        })
+        mockedUseFetchChallengeTypes.mockReturnValue({
+            challengeTypes: [{
+                abbreviation: 'CH',
+                id: 'design-challenge-type-id',
+                name: 'Challenge',
+            }],
+            isLoading: false,
+        })
+        const adminContextValue: WorkAppContextModel = {
+            ...copilotContextValue,
+            isAdmin: true,
+            userRoles: ['administrator'],
+        }
+
+        render(
+            <MemoryRouter>
+                <WorkAppContext.Provider value={adminContextValue}>
+                    <ChallengeEditorForm challenge={designChallengeWithDeferredScreener} />
+                </WorkAppContext.Provider>
+            </MemoryRouter>,
+        )
+
+        expect(screen.getByTestId('reviewers-field'))
+            .toHaveAttribute('data-screener-only', 'false')
+    })
+
+    it('keeps the full review configuration for a copilot editing a Design First2Finish', () => {
+        mockedUseFetchChallengeTracks.mockReturnValue({
+            isLoading: false,
+            tracks: [{
+                id: 'design-track',
+                name: 'Design',
+                track: 'DESIGN',
+            }],
+        })
+        mockedUseFetchChallengeTypes.mockReturnValue({
+            challengeTypes: [{
+                abbreviation: 'F2F',
+                id: 'design-first2finish',
+                name: 'First2Finish',
+            }],
+            isLoading: false,
+        })
+
+        render(
+            <MemoryRouter>
+                <WorkAppContext.Provider value={copilotContextValue}>
+                    <ChallengeEditorForm challenge={first2FinishDraftChallenge} />
+                </WorkAppContext.Provider>
+            </MemoryRouter>,
+        )
+
+        expect(screen.getByTestId('reviewers-field'))
+            .toHaveAttribute('data-screener-only', 'false')
+    })
+
     it('does not delete manual iterative reviewer resources when saving a first2finish draft', async () => {
         const user = userEvent.setup()
 
diff --git a/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ChallengeEditorForm.tsx b/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ChallengeEditorForm.tsx
index c8ceb7d9f..ad5303a4a 100644
--- a/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ChallengeEditorForm.tsx
+++ b/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ChallengeEditorForm.tsx
@@ -2017,17 +2017,17 @@ export const ChallengeEditorForm: FC<ChallengeEditorFormProps> = (
     )
     const isChallengeTypeSelected = useMemo(
         (): boolean => {
-            const normalizedChallengeTypeName = (selectedChallengeType?.name || '')
+            const normalizedChallengeTypeName = (resolvedChallengeTypeName || '')
                 .trim()
                 .toUpperCase()
-            const normalizedChallengeTypeAbbreviation = (selectedChallengeType?.abbreviation || '')
+            const normalizedChallengeTypeAbbreviation = (resolvedChallengeTypeAbbreviation || '')
                 .trim()
                 .toUpperCase()
 
             return normalizedChallengeTypeName === CHALLENGE_TYPE_CHALLENGE_NAME
                 || normalizedChallengeTypeAbbreviation === CHALLENGE_TYPE_CHALLENGE_ABBREVIATION
         },
-        [selectedChallengeType],
+        [resolvedChallengeTypeAbbreviation, resolvedChallengeTypeName],
     )
     const isTaskChallengeSelected = useMemo(
         (): boolean => isTaskChallengeType(selectedChallengeType)
@@ -2219,6 +2219,9 @@ export const ChallengeEditorForm: FC<ChallengeEditorFormProps> = (
     const shouldUseCopilotBillingSummary = workAppContext.isCopilot
         && !workAppContext.isAdmin
         && !workAppContext.isManager
+    const shouldUseSimplifiedDesignReview = shouldUseCopilotBillingSummary
+        && isDesignTrackSelected
+        && isChallengeTypeSelected
     const getPersistedAssignmentValueByFields = useCallback((
         fallbackValue: string | undefined,
         roleNames: readonly string[],
@@ -3838,6 +3841,7 @@ export const ChallengeEditorForm: FC<ChallengeEditorFormProps> = (
                         onConfigSaveControllerReady={function (controller: AiReviewConfigSaveController | undefined) {
                             aiReviewConfigSaveControllerRef.current = controller
                         }}
+                        screenerOnly={shouldUseSimplifiedDesignReview}
                     />
                 </div>
             </section>
diff --git a/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ReviewersField/HumanReviewTab.spec.tsx b/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ReviewersField/HumanReviewTab.spec.tsx
index ee86b0b1f..da18e1f62 100644
--- a/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ReviewersField/HumanReviewTab.spec.tsx
+++ b/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ReviewersField/HumanReviewTab.spec.tsx
@@ -32,6 +32,7 @@ import {
     MAX_MANUAL_REVIEWER_COUNT,
 } from '../../../../../lib/constants/challenge-editor.constants'
 import {
+    createResource,
     deleteResource,
     fetchDefaultReviewers,
     fetchProfile,
@@ -68,6 +69,7 @@ jest.mock('../../../../../lib/components/form', () => ({
             control: formContext.control,
             name: props.name,
         })
+
         const selectedValue = typeof controller.field.value === 'string'
             ? controller.field.value
             : ''
@@ -156,8 +158,11 @@ jest.mock('../../../../../lib/components/form', () => ({
         )
     },
     FormUserAutocomplete: (props: {
+        disabled?: boolean
         label: string
         name: string
+        onValueChange?: (value: string) => void
+        placeholder?: string
         required?: boolean
     }) => {
         const {
@@ -170,13 +175,26 @@ jest.mock('../../../../../lib/components/form', () => ({
             name: props.name,
         })
 
+        function handleChange(event: ChangeEvent<HTMLInputElement>): void {
+            props.onValueChange?.(event.target.value)
+            controller.field.onChange(event.target.value)
+        }
+
         return (
             <div
                 data-required={String(props.required === true)}
                 data-testid={props.name}
                 data-value={controller.field.value || ''}
             >
-                <span>{props.label}</span>
+                <label htmlFor={props.name}>{props.label}</label>
+                <input
+                    aria-label={props.label}
+                    disabled={props.disabled}
+                    id={props.name}
+                    onChange={handleChange}
+                    placeholder={props.placeholder}
+                    value={controller.field.value || ''}
+                />
             </div>
         )
     },
@@ -221,6 +239,7 @@ const mockedUseFetchChallengeTracks = useFetchChallengeTracks as jest.Mock
 const mockedUseFetchChallengeTypes = useFetchChallengeTypes as jest.Mock
 const mockedUseFetchResourceRoles = useFetchResourceRoles as jest.Mock
 const mockedUseFetchResources = useFetchResources as jest.Mock
+const mockedCreateResource = createResource as jest.Mock
 const mockedDeleteResource = deleteResource as jest.Mock
 const mockedFetchDefaultReviewers = fetchDefaultReviewers as jest.Mock
 const mockedFetchProfile = fetchProfile as jest.Mock
@@ -257,11 +276,14 @@ interface TestHarnessProps {
     restoreStaleScorecardId?: boolean
     showAdditionalMemberIdsValue?: boolean
     showMemberValue?: boolean
+    showMemberValueIndex?: number
+    showSecondMemberValue?: boolean
     showPublicOpportunityValue?: boolean
     showRoleValue?: boolean
     showRoleValueIndex?: number
     showScorecardValue?: boolean
     showScorecardValueIndex?: number
+    screenerOnly?: boolean
 }
 
 const baseDefaultValues: ChallengeEditorFormData = {
@@ -398,6 +420,7 @@ const TestHarness = (props: TestHarnessProps): JSX.Element => {
     })
     const roleValueIndex = props.showRoleValueIndex ?? 0
     const scorecardValueIndex = props.showScorecardValueIndex ?? 0
+    const memberValueIndex = props.showMemberValueIndex ?? 0
 
     useEffect(() => {
         if (!props.initialScorecardErrorMessage) {
@@ -415,7 +438,7 @@ const TestHarness = (props: TestHarnessProps): JSX.Element => {
 
     return (
         <FormProvider {...formMethods}>
-            <HumanReviewTab />
+            <HumanReviewTab screenerOnly={props.screenerOnly} />
             {props.restoreStaleAdditionalMemberIds
                 ? <StaleAdditionalMemberIdsReporter />
                 : undefined}
@@ -434,7 +457,14 @@ const TestHarness = (props: TestHarnessProps): JSX.Element => {
             {props.showMemberValue
                 ? (
                     <div data-testid='member-id-value'>
-                        {formMethods.watch('reviewers.0.memberId') || ''}
+                        {String(formMethods.watch(`reviewers.${memberValueIndex}.memberId` as never) || '')}
+                    </div>
+                )
+                : undefined}
+            {props.showSecondMemberValue
+                ? (
+                    <div data-testid='second-member-id-value'>
+                        {formMethods.watch('reviewers.1.memberId') || ''}
                     </div>
                 )
                 : undefined}
@@ -498,6 +528,7 @@ describe('HumanReviewTab', () => {
                 .mockResolvedValue(undefined),
             resources: [],
         })
+        mockedCreateResource.mockResolvedValue(undefined)
         mockedDeleteResource.mockResolvedValue(undefined)
         mockedFetchDefaultReviewers.mockImplementation(() => createPendingPromise())
         mockedFetchProfile.mockResolvedValue(undefined)
@@ -992,6 +1023,581 @@ describe('HumanReviewTab', () => {
             .toHaveProperty('dataset.required', 'true')
     })
 
+    it('assigns one simplified screener selection to checkpoint and final screening roles', async () => {
+        const mutateResources = jest.fn()
+            .mockResolvedValue(undefined)
+        mockedUseFetchChallengeTracks.mockReturnValue({
+            tracks: [{
+                id: 'track-1',
+                name: 'Design',
+                track: 'DESIGN',
+            }],
+        })
+        mockedUseFetchResourceRoles.mockReturnValue({
+            isLoading: false,
+            resourceRoles: [
+                {
+                    id: 'checkpoint-screener-role-id',
+                    name: 'Checkpoint Screener',
+                },
+                {
+                    id: 'screener-role-id',
+                    name: 'Screener',
+                },
+            ],
+        })
+        mockedUseFetchResources.mockReturnValue({
+            isLoading: false,
+            mutate: mutateResources,
+            resources: [],
+        })
+
+        render(
+            <TestHarness
+                defaultValues={{
+                    phases: [
+                        {
+                            name: 'Checkpoint Screening',
+                            phaseId: 'checkpoint-screening-phase-id',
+                        },
+                        {
+                            name: 'Screening',
+                            phaseId: 'screening-phase-id',
+                        },
+                    ],
+                    reviewers: [
+                        {
+                            isMemberReview: true,
+                            memberReviewerCount: 1,
+                            phaseId: 'checkpoint-screening-phase-id',
+                            scorecardId: 'checkpoint-screening-scorecard-id',
+                            shouldOpenOpportunity: false,
+                        },
+                        {
+                            isMemberReview: true,
+                            memberReviewerCount: 1,
+                            phaseId: 'screening-phase-id',
+                            scorecardId: 'screening-scorecard-id',
+                            shouldOpenOpportunity: false,
+                        },
+                    ],
+                }}
+                screenerOnly
+                showMemberValue
+                showMemberValueIndex={0}
+                showSecondMemberValue
+                showScorecardValue
+                showScorecardValueIndex={0}
+            />,
+        )
+
+        expect(screen.getByLabelText('Screener')
+            .getAttribute('placeholder'))
+            .toBe('Select user')
+        expect(screen.queryByLabelText('Phase'))
+            .toBeNull()
+        expect(screen.queryByLabelText('Scorecard'))
+            .toBeNull()
+
+        fireEvent.change(screen.getByLabelText('Screener'), {
+            target: {
+                value: 'screener-member-id',
+            },
+        })
+
+        await waitFor(() => {
+            expect(screen.getByTestId('member-id-value').textContent)
+                .toBe('screener-member-id')
+            expect(screen.getByTestId('second-member-id-value').textContent)
+                .toBe('screener-member-id')
+            expect((screen.getByLabelText('Screener') as HTMLInputElement).value)
+                .toBe('screener-member-id')
+            expect(mockedCreateResource.mock.calls)
+                .toEqual(expect.arrayContaining([
+                    [{
+                        challengeId: 'challenge-1',
+                        memberId: 'screener-member-id',
+                        roleId: 'checkpoint-screener-role-id',
+                    }],
+                    [{
+                        challengeId: 'challenge-1',
+                        memberId: 'screener-member-id',
+                        roleId: 'screener-role-id',
+                    }],
+                ]))
+        })
+        expect(screen.getByTestId('scorecard-id-value').textContent)
+            .toBe('checkpoint-screening-scorecard-id')
+        expect(mockedCreateResource)
+            .toHaveBeenCalledTimes(2)
+        expect(mockedDeleteResource)
+            .not.toHaveBeenCalled()
+        await waitFor(() => {
+            expect(mutateResources)
+                .toHaveBeenCalled()
+        })
+    })
+
+    it('disables simplified screener changes while both resource assignments synchronize', async () => {
+        const resourceCreateRequest = createDeferredPromise<void>()
+        mockedUseFetchChallengeTracks.mockReturnValue({
+            tracks: [{
+                id: 'track-1',
+                name: 'Design',
+                track: 'DESIGN',
+            }],
+        })
+        mockedUseFetchResourceRoles.mockReturnValue({
+            isLoading: false,
+            resourceRoles: [
+                {
+                    id: 'checkpoint-screener-role-id',
+                    name: 'Checkpoint Screener',
+                },
+                {
+                    id: 'screener-role-id',
+                    name: 'Screener',
+                },
+            ],
+        })
+        mockedUseFetchResources.mockReturnValue({
+            isError: false,
+            isLoading: false,
+            mutate: jest.fn()
+                .mockResolvedValue(undefined),
+            resources: [],
+        })
+        mockedCreateResource.mockReturnValue(resourceCreateRequest.promise)
+
+        render(
+            <TestHarness
+                defaultValues={{
+                    phases: [
+                        {
+                            name: 'Checkpoint Screening',
+                            phaseId: 'checkpoint-screening-phase-id',
+                        },
+                        {
+                            name: 'Screening',
+                            phaseId: 'screening-phase-id',
+                        },
+                    ],
+                    reviewers: [
+                        {
+                            isMemberReview: true,
+                            memberReviewerCount: 1,
+                            phaseId: 'checkpoint-screening-phase-id',
+                        },
+                        {
+                            isMemberReview: true,
+                            memberReviewerCount: 1,
+                            phaseId: 'screening-phase-id',
+                        },
+                    ],
+                }}
+                screenerOnly
+            />,
+        )
+
+        const screenerField = screen.getByLabelText('Screener') as HTMLInputElement
+
+        fireEvent.change(screenerField, {
+            target: {
+                value: 'first-member-id',
+            },
+        })
+
+        await waitFor(() => {
+            expect(screenerField.disabled)
+                .toBe(true)
+        })
+        fireEvent.change(screenerField, {
+            target: {
+                value: 'second-member-id',
+            },
+        })
+        expect(mockedCreateResource)
+            .toHaveBeenCalledTimes(2)
+
+        await act(async () => {
+            resourceCreateRequest.resolve(undefined)
+            await resourceCreateRequest.promise
+        })
+        await waitFor(() => {
+            expect(screenerField.disabled)
+                .toBe(false)
+        })
+    })
+
+    it('disables simplified screener assignment when challenge resources fail to load', () => {
+        mockedUseFetchChallengeTracks.mockReturnValue({
+            tracks: [{
+                id: 'track-1',
+                name: 'Design',
+                track: 'DESIGN',
+            }],
+        })
+        mockedUseFetchResourceRoles.mockReturnValue({
+            isLoading: false,
+            resourceRoles: [{
+                id: 'screener-role-id',
+                name: 'Screener',
+            }],
+        })
+        mockedUseFetchResources.mockReturnValue({
+            isError: true,
+            isLoading: false,
+            mutate: jest.fn()
+                .mockResolvedValue(undefined),
+            resources: [],
+        })
+
+        render(
+            <TestHarness
+                defaultValues={{
+                    phases: [{
+                        name: 'Screening',
+                        phaseId: 'screening-phase-id',
+                    }],
+                    reviewers: [{
+                        isMemberReview: true,
+                        memberReviewerCount: 1,
+                        phaseId: 'screening-phase-id',
+                    }],
+                }}
+                screenerOnly
+            />,
+        )
+
+        expect((screen.getByLabelText('Screener') as HTMLInputElement).disabled)
+            .toBe(true)
+        expect(screen.getByText('Unable to load screener assignments.'))
+            .not.toBeNull()
+    })
+
+    it('replaces existing checkpoint and final screener resources together', async () => {
+        mockedUseFetchChallengeTracks.mockReturnValue({
+            tracks: [{
+                id: 'track-1',
+                name: 'Design',
+                track: 'DESIGN',
+            }],
+        })
+        mockedUseFetchResourceRoles.mockReturnValue({
+            isLoading: false,
+            resourceRoles: [
+                {
+                    id: 'checkpoint-screener-role-id',
+                    name: 'Checkpoint Screener',
+                },
+                {
+                    id: 'screener-role-id',
+                    name: 'Screener',
+                },
+            ],
+        })
+        mockedUseFetchResources.mockReturnValue({
+            isLoading: false,
+            mutate: jest.fn()
+                .mockResolvedValue(undefined),
+            resources: [
+                {
+                    challengeId: 'challenge-1',
+                    memberId: 'old-member-id',
+                    roleId: 'checkpoint-screener-role-id',
+                    roleName: 'Checkpoint Screener',
+                },
+                {
+                    challengeId: 'challenge-1',
+                    memberId: 'old-member-id',
+                    roleId: 'screener-role-id',
+                    roleName: 'Screener',
+                },
+            ],
+        })
+
+        render(
+            <TestHarness
+                defaultValues={{
+                    phases: [
+                        {
+                            name: 'Checkpoint Screening',
+                            phaseId: 'checkpoint-screening-phase-id',
+                        },
+                        {
+                            name: 'Screening',
+                            phaseId: 'screening-phase-id',
+                        },
+                    ],
+                    reviewers: [
+                        {
+                            isMemberReview: true,
+                            memberId: 'old-member-id',
+                            memberReviewerCount: 1,
+                            phaseId: 'checkpoint-screening-phase-id',
+                            scorecardId: 'checkpoint-scorecard-id',
+                        },
+                        {
+                            isMemberReview: true,
+                            memberId: 'old-member-id',
+                            memberReviewerCount: 1,
+                            phaseId: 'screening-phase-id',
+                            scorecardId: 'screening-scorecard-id',
+                        },
+                    ],
+                }}
+                screenerOnly
+            />,
+        )
+
+        fireEvent.change(screen.getByLabelText('Screener'), {
+            target: {
+                value: 'new-member-id',
+            },
+        })
+
+        await waitFor(() => {
+            expect(mockedDeleteResource.mock.calls)
+                .toEqual(expect.arrayContaining([
+                    [{
+                        challengeId: 'challenge-1',
+                        memberHandle: undefined,
+                        memberId: 'old-member-id',
+                        roleId: 'checkpoint-screener-role-id',
+                    }],
+                    [{
+                        challengeId: 'challenge-1',
+                        memberHandle: undefined,
+                        memberId: 'old-member-id',
+                        roleId: 'screener-role-id',
+                    }],
+                ]))
+        })
+        expect(mockedCreateResource)
+            .toHaveBeenCalledTimes(2)
+        expect(mockedDeleteResource)
+            .toHaveBeenCalledTimes(2)
+    })
+
+    it('clears existing checkpoint and final screener resources together', async () => {
+        mockedUseFetchChallengeTracks.mockReturnValue({
+            tracks: [{
+                id: 'track-1',
+                name: 'Design',
+                track: 'DESIGN',
+            }],
+        })
+        mockedUseFetchResourceRoles.mockReturnValue({
+            isLoading: false,
+            resourceRoles: [
+                {
+                    id: 'checkpoint-screener-role-id',
+                    name: 'Checkpoint Screener',
+                },
+                {
+                    id: 'screener-role-id',
+                    name: 'Screener',
+                },
+            ],
+        })
+        mockedUseFetchResources.mockReturnValue({
+            isError: false,
+            isLoading: false,
+            mutate: jest.fn()
+                .mockResolvedValue(undefined),
+            resources: [
+                {
+                    challengeId: 'challenge-1',
+                    memberId: 'old-member-id',
+                    roleId: 'checkpoint-screener-role-id',
+                    roleName: 'Checkpoint Screener',
+                },
+                {
+                    challengeId: 'challenge-1',
+                    memberId: 'old-member-id',
+                    roleId: 'screener-role-id',
+                    roleName: 'Screener',
+                },
+            ],
+        })
+
+        render(
+            <TestHarness
+                defaultValues={{
+                    phases: [
+                        {
+                            name: 'Checkpoint Screening',
+                            phaseId: 'checkpoint-screening-phase-id',
+                        },
+                        {
+                            name: 'Screening',
+                            phaseId: 'screening-phase-id',
+                        },
+                    ],
+                    reviewers: [
+                        {
+                            isMemberReview: true,
+                            memberId: 'old-member-id',
+                            memberReviewerCount: 1,
+                            phaseId: 'checkpoint-screening-phase-id',
+                        },
+                        {
+                            isMemberReview: true,
+                            memberId: 'old-member-id',
+                            memberReviewerCount: 1,
+                            phaseId: 'screening-phase-id',
+                        },
+                    ],
+                }}
+                screenerOnly
+            />,
+        )
+
+        fireEvent.change(screen.getByLabelText('Screener'), {
+            target: {
+                value: '',
+            },
+        })
+
+        await waitFor(() => {
+            expect(mockedDeleteResource)
+                .toHaveBeenCalledTimes(2)
+        })
+        expect(mockedCreateResource)
+            .not.toHaveBeenCalled()
+    })
+
+    it('does not duplicate a hydrated handle-only screener resource', async () => {
+        const mutateResources = jest.fn()
+            .mockResolvedValue(undefined)
+        mockedUseFetchChallengeTracks.mockReturnValue({
+            tracks: [{
+                id: 'track-1',
+                name: 'Design',
+                track: 'DESIGN',
+            }],
+        })
+        mockedUseFetchResourceRoles.mockReturnValue({
+            isLoading: false,
+            resourceRoles: [{
+                id: 'screener-role-id',
+                name: 'Screener',
+            }],
+        })
+        mockedUseFetchResources.mockReturnValue({
+            isError: false,
+            isLoading: false,
+            mutate: mutateResources,
+            resources: [{
+                challengeId: 'challenge-1',
+                memberHandle: 'legacy.screener',
+                roleId: 'screener-role-id',
+                roleName: 'Screener',
+            }],
+        })
+        mockedFetchProfile.mockResolvedValue({
+            handle: 'legacy.screener',
+            userId: 'legacy-member-id',
+        })
+
+        render(
+            <TestHarness
+                defaultValues={{
+                    phases: [{
+                        name: 'Screening',
+                        phaseId: 'screening-phase-id',
+                    }],
+                    reviewers: [{
+                        isMemberReview: true,
+                        memberReviewerCount: 1,
+                        phaseId: 'screening-phase-id',
+                    }],
+                }}
+                screenerOnly
+            />,
+        )
+
+        await waitFor(() => {
+            expect((screen.getByLabelText('Screener') as HTMLInputElement).value)
+                .toBe('legacy-member-id')
+            expect((screen.getByLabelText('Screener') as HTMLInputElement).disabled)
+                .toBe(false)
+        })
+
+        fireEvent.change(screen.getByLabelText('Screener'), {
+            target: {
+                value: ' legacy-member-id ',
+            },
+        })
+
+        await waitFor(() => {
+            expect(mutateResources)
+                .toHaveBeenCalled()
+        })
+        expect(mockedCreateResource)
+            .not.toHaveBeenCalled()
+        expect(mockedDeleteResource)
+            .not.toHaveBeenCalled()
+    })
+
+    it('assigns only the final Screener role for one-round design challenges', async () => {
+        mockedUseFetchChallengeTracks.mockReturnValue({
+            tracks: [{
+                id: 'track-1',
+                name: 'Design',
+                track: 'DESIGN',
+            }],
+        })
+        mockedUseFetchResourceRoles.mockReturnValue({
+            isLoading: false,
+            resourceRoles: [{
+                id: 'screener-role-id',
+                name: 'Screener',
+            }],
+        })
+        mockedUseFetchResources.mockReturnValue({
+            isLoading: false,
+            mutate: jest.fn()
+                .mockResolvedValue(undefined),
+            resources: [],
+        })
+
+        render(
+            <TestHarness
+                defaultValues={{
+                    phases: [{
+                        name: 'Screening',
+                        phaseId: 'screening-phase-id',
+                    }],
+                    reviewers: [{
+                        isMemberReview: true,
+                        memberReviewerCount: 1,
+                        phaseId: 'screening-phase-id',
+                        scorecardId: 'screening-scorecard-id',
+                    }],
+                }}
+                screenerOnly
+            />,
+        )
+
+        fireEvent.change(screen.getByLabelText('Screener'), {
+            target: {
+                value: 'screener-member-id',
+            },
+        })
+
+        await waitFor(() => {
+            expect(mockedCreateResource)
+                .toHaveBeenCalledWith({
+                    challengeId: 'challenge-1',
+                    memberId: 'screener-member-id',
+                    roleId: 'screener-role-id',
+                })
+        })
+        expect(mockedCreateResource)
+            .toHaveBeenCalledTimes(1)
+    })
+
     it('defaults new manual reviewer cards to regular review type', async () => {
         mockedFetchScorecards.mockResolvedValue([])
 
diff --git a/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ReviewersField/HumanReviewTab.tsx b/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ReviewersField/HumanReviewTab.tsx
index 0da18bd3e..e7f11a3af 100644
--- a/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ReviewersField/HumanReviewTab.tsx
+++ b/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ReviewersField/HumanReviewTab.tsx
@@ -36,6 +36,8 @@ import {
     ChallengeEditorFormData,
     DefaultReviewer,
     Resource,
+    ResourcePayload,
+    ResourceRole,
     Reviewer,
     Scorecard,
 } from '../../../../../lib/models'
@@ -88,6 +90,10 @@ const APPEAL_PHASE_KEYS = new Set([
     'appeals',
     'appealsresponse',
 ])
+const SCREENER_ROLE_NAME_BY_PHASE_KEY: Record<string, string> = {
+    checkpointscreening: 'Checkpoint Screener',
+    screening: 'Screener',
+}
 const REVIEW_OPPORTUNITY_TYPES = {
     COMPONENT_DEV_REVIEW: 'COMPONENT_DEV_REVIEW',
     ITERATIVE_REVIEW: 'ITERATIVE_REVIEW',
@@ -595,12 +601,12 @@ function getReviewOpportunityTypeForReviewer(params: {
 function getRoleNameForPhaseName(phaseName: string | undefined): string {
     const normalizedPhaseName = normalizeKey(phaseName)
 
-    if (normalizedPhaseName === 'approval') {
-        return 'Approver'
+    if (SCREENER_ROLE_NAME_BY_PHASE_KEY[normalizedPhaseName]) {
+        return SCREENER_ROLE_NAME_BY_PHASE_KEY[normalizedPhaseName]
     }
 
-    if (normalizedPhaseName === 'checkpointscreening') {
-        return 'Checkpoint Screener'
+    if (normalizedPhaseName === 'approval') {
+        return 'Approver'
     }
 
     if (normalizedPhaseName === 'checkpointreview') {
@@ -611,11 +617,153 @@ function getRoleNameForPhaseName(phaseName: string | undefined): string {
         return 'Iterative Reviewer'
     }
 
-    if (normalizedPhaseName === 'screening') {
-        return 'Screener'
+    return 'Reviewer'
+}
+
+interface ScreenerResourceTarget {
+    assignedMemberIds: string[]
+    assignedResources: Resource[]
+    roleId: string
+    roleName: string
+}
+
+interface ScreenerReviewerEntry {
+    fieldIndex: number
+    reviewer: Reviewer
+    roleName: string
+}
+
+/**
+ * Resolves a screener resource member id, including a hydrated id for legacy handle-only rows.
+ *
+ * @param target screening-role resource target and its hydrated form assignments.
+ * @param resourceIndex persisted resource position within the target.
+ * @returns the normalized member id, or an empty string while a handle remains unresolved.
+ * @throws Does not throw.
+ */
+function getScreenerResourceMemberId(
+    target: ScreenerResourceTarget,
+    resourceIndex: number,
+): string {
+    return normalizeText(target.assignedResources[resourceIndex]?.memberId)
+        || normalizeText(target.assignedMemberIds[resourceIndex])
+}
+
+/**
+ * Builds the resource payload used to remove or restore an existing screener assignment.
+ *
+ * @param resource persisted challenge resource for a screening role.
+ * @returns a resource mutation payload, or `undefined` when the resource has no member identity.
+ * @remarks Used while synchronizing the simplified Design Challenge screener field.
+ * @throws Does not throw.
+ */
+function getResourceMutationPayload(resource: Resource): ResourcePayload | undefined {
+    const memberId = normalizeText(resource.memberId)
+    const memberHandle = normalizeText(resource.memberHandle)
+    const roleId = normalizeText(resource.roleId)
+
+    if (!roleId || (!memberId && !memberHandle)) {
+        return undefined
+    }
+
+    return {
+        challengeId: resource.challengeId,
+        memberHandle: memberId ? undefined : memberHandle,
+        memberId: memberId || undefined,
+        roleId,
     }
+}
 
-    return 'Reviewer'
+/**
+ * Finds persisted challenge resources for one named screening role.
+ *
+ * @param resources challenge resources available to the editor.
+ * @param resourceRoles resource-role metadata used when a resource only exposes a role id.
+ * @param roleName screening role name to match.
+ * @returns all resources assigned to the requested role.
+ * @remarks Role names and ids are both supported for legacy resource payloads.
+ * @throws Does not throw.
+ */
+function getResourcesForRoleName(
+    resources: Resource[],
+    resourceRoles: ResourceRole[],
+    roleName: string,
+): Resource[] {
+    const normalizedRoleName = normalizeKey(roleName)
+    const matchingRoleIds = new Set(resourceRoles
+        .filter(role => normalizeKey(role.name) === normalizedRoleName)
+        .map(role => normalizeText(role.id)))
+
+    return resources.filter(resource => (
+        normalizeKey(resource.roleName || resource.role) === normalizedRoleName
+        || matchingRoleIds.has(normalizeText(resource.roleId))
+    ))
+}
+
+/**
+ * Replaces the persisted assignments for every screening role with one selected member.
+ *
+ * @param params challenge id, selected member id, and screening-role resource targets.
+ * @returns a promise that resolves after all resource roles match the selected member.
+ * @remarks New assignments are created before old assignments are removed. Completed mutations
+ * are rolled back on failure so Checkpoint Screener and Screener do not remain out of sync.
+ * @throws Re-throws the resource service error after attempting rollback.
+ */
+async function syncScreenerResourceAssignments(params: {
+    challengeId: string
+    selectedMemberId: string
+    targets: ScreenerResourceTarget[]
+}): Promise<void> {
+    const createdPayloads: ResourcePayload[] = []
+    const deletedPayloads: ResourcePayload[] = []
+    const createPayloads = params.selectedMemberId
+        ? params.targets
+            .filter(target => !target.assignedResources.some((resource, resourceIndex) => (
+                getScreenerResourceMemberId(target, resourceIndex) === params.selectedMemberId
+            )))
+            .map(target => ({
+                challengeId: params.challengeId,
+                memberId: params.selectedMemberId,
+                roleId: target.roleId,
+            }))
+        : []
+    const deletePayloads = params.targets
+        .flatMap(target => target.assignedResources
+            .filter((resource, resourceIndex) => (
+                !params.selectedMemberId
+                || getScreenerResourceMemberId(target, resourceIndex) !== params.selectedMemberId
+            )))
+        .map(getResourceMutationPayload)
+        .filter((payload): payload is ResourcePayload => !!payload)
+
+    try {
+        const createResults = await Promise.allSettled(createPayloads.map(async payload => {
+            await createResource(payload)
+            createdPayloads.push(payload)
+        }))
+        const failedCreate = createResults.find(result => result.status === 'rejected') as PromiseRejectedResult
+            | undefined
+        if (failedCreate) {
+            throw failedCreate.reason
+        }
+
+        const deleteResults = await Promise.allSettled(deletePayloads.map(async payload => {
+            await deleteResource(payload)
+            deletedPayloads.push(payload)
+        }))
+        const failedDelete = deleteResults.find(result => result.status === 'rejected') as PromiseRejectedResult
+            | undefined
+        if (failedDelete) {
+            throw failedDelete.reason
+        }
+    } catch (error) {
+        await Promise.allSettled([
+            ...createdPayloads.map(payload => deleteResource(payload)),
+            ...deletedPayloads.map(payload => createResource(payload)),
+        ])
+
+        throw error
+    }
 }
 
 /**
@@ -817,7 +965,15 @@ const PublicOpportunityCheckboxField: FC<PublicOpportunityCheckboxFieldProps> =
     )
 }
 
-export const HumanReviewTab: FC = () => {
+interface HumanReviewTabProps {
+    screenerOnly?: boolean
+}
+
+/**
+ * Renders manual reviewer configuration, or a single synchronized screener field
+ * for copilot-only Design Challenge editing.
+ */
+export const HumanReviewTab: FC<HumanReviewTabProps> = (props: HumanReviewTabProps) => {
     const formContext = useFormContext<ChallengeEditorFormData>()
     const reviewersFieldState = useController({
         control: formContext.control,
@@ -828,15 +984,16 @@ export const HumanReviewTab: FC = () => {
     const challengeTracks = challengeTracksResult.tracks
     const challengeTypes = challengeTypesResult.challengeTypes
 
-    const {
-        resourceRoles,
-    }: UseFetchResourceRolesResult = useFetchResourceRoles()
+    const resourceRolesResult: UseFetchResourceRolesResult = useFetchResourceRoles()
+    const resourceRoles = resourceRolesResult.resourceRoles
 
     const [defaultReviewers, setDefaultReviewers] = useState<DefaultReviewer[]>([])
     const [scorecards, setScorecards] = useState<Scorecard[]>([])
     // Keep existing selections intact until the first scorecard fetch resolves.
     const [isScorecardsLoading, setIsScorecardsLoading] = useState<boolean>(true)
+    const [isScreenerSyncing, setIsScreenerSyncing] = useState<boolean>(false)
     const [loadError, setLoadError] = useState<string | undefined>()
+    const isScreenerSyncingRef = useRef<boolean>(false)
     const autoBackfilledReviewerTypesRef = useRef<Record<string, string>>({})
     const trimmedAdditionalMemberIdsRef = useRef<Record<string, string>>({})
     const reconciledScorecardSelectionsRef = useRef<Record<string, string>>({})
@@ -912,10 +1069,15 @@ export const HumanReviewTab: FC = () => {
 
             phases.forEach(phase => {
                 const phaseName = normalizeText(phase.name)
-                const phaseId = normalizeText(phase.phaseId) || normalizeText(phase.id)
-
-                if (phaseId && phaseName) {
-                    nextPhaseNameById.set(phaseId, phaseName)
+                const phaseIds = toUniqueValues([
+                    normalizeText(phase.phaseId),
+                    normalizeText(phase.id),
+                ])
+
+                if (phaseName) {
+                    phaseIds.forEach(phaseId => {
+                        nextPhaseNameById.set(phaseId, phaseName)
+                    })
                 }
             })
 
@@ -975,6 +1137,106 @@ export const HumanReviewTab: FC = () => {
         [resolveRoleIdForPhase],
     )
 
+    const screenerReviewerEntries = useMemo<ScreenerReviewerEntry[]>(
+        () => reviewerRows
+            .map((reviewer, reviewerIndex) => {
+                const fieldIndex = getReviewerFieldIndex(reviewerIndex)
+                const phaseName = phaseNameById.get(normalizeText(reviewer.phaseId))
+                const roleName = SCREENER_ROLE_NAME_BY_PHASE_KEY[normalizeKey(phaseName)]
+
+                return fieldIndex !== undefined && roleName
+                    ? {
+                        fieldIndex,
+                        reviewer,
+                        roleName,
+                    }
+                    : undefined
+            })
+            .filter((entry): entry is ScreenerReviewerEntry => !!entry),
+        [
+            getReviewerFieldIndex,
+            phaseNameById,
+            reviewerRows,
+        ],
+    )
+    const screenerRoleNames = useMemo<string[]>(
+        () => toUniqueValues([
+            ...(Array.isArray(phases)
+                ? phases
+                    .map(phase => SCREENER_ROLE_NAME_BY_PHASE_KEY[normalizeKey(phase.name)])
+                    .filter(Boolean)
+                : []),
+            ...screenerReviewerEntries.map(entry => entry.roleName),
+        ]),
+        [
+            phases,
+            screenerReviewerEntries,
+        ],
+    )
+    const screenerResourceTargets = useMemo<ScreenerResourceTarget[]>(
+        () => screenerRoleNames
+            .map(roleName => {
+                const normalizedRoleName = normalizeKey(roleName)
+                const assignedResources = getResourcesForRoleName(
+                    challengeResourcesResult.resources,
+                    resourceRoles,
+                    roleName,
+                )
+                const reviewerRoleId = normalizeText(screenerReviewerEntries
+                    .find(entry => entry.roleName === roleName)
+                    ?.reviewer.roleId)
+                const reviewerRoleMatches = resourceRoles.some(role => (
+                    normalizeText(role.id) === reviewerRoleId
+                    && normalizeKey(role.name) === normalizedRoleName
+                )) || assignedResources.some(resource => (
+                    normalizeText(resource.roleId) === reviewerRoleId
+                ))
+                const roleId = (reviewerRoleMatches ? reviewerRoleId : '')
+                    || normalizeText(assignedResources[0]?.roleId)
+                    || normalizeText(roleIdByName.get(normalizedRoleName))
+
+                return roleId
+                    ? {
+                        assignedMemberIds: getAssignedMemberIds(screenerReviewerEntries
+                            .find(entry => entry.roleName === roleName)
+                            ?.reviewer),
+                        assignedResources,
+                        roleId,
+                        roleName,
+                    }
+                    : undefined
+            })
+            .filter((target): target is ScreenerResourceTarget => !!target),
+        [
+            challengeResourcesResult.resources,
+            resourceRoles,
+            roleIdByName,
+            screenerReviewerEntries,
+            screenerRoleNames,
+        ],
+    )
+    const primaryScreenerReviewerEntry = useMemo<ScreenerReviewerEntry | undefined>(() => {
+        const finalScreenerEntry = screenerReviewerEntries.find(entry => entry.roleName === 'Screener')
+
+        if (finalScreenerEntry && getAssignedMemberIds(finalScreenerEntry.reviewer)
+            .some(Boolean)) {
+            return finalScreenerEntry
+        }
+
+        return screenerReviewerEntries.find(entry => getAssignedMemberIds(entry.reviewer)
+            .some(Boolean))
+            || finalScreenerEntry
+            || screenerReviewerEntries[0]
+    }, [screenerReviewerEntries])
+    const hasMissingScreenerRole = screenerResourceTargets.length < screenerRoleNames.length
+    const hasUnresolvedScreenerAssignment = screenerResourceTargets.some(target => (
+        target.assignedResources.some((resource, resourceIndex) => (
+            !normalizeText(resource.memberId)
+            && !!normalizeText(resource.memberHandle)
+            && !normalizeText(target.assignedMemberIds[resourceIndex])
+        ))
+    ))
+
     const phaseOptions = useMemo<FormSelectOption[]>(
         () => (Array.isArray(phases)
             ? phases
@@ -1449,12 +1711,12 @@ export const HumanReviewTab: FC = () => {
         },
         [],
     )
-    const refreshChallengeResources = useCallback((): void => {
+    const refreshChallengeResources = useCallback((): Promise<unknown> | undefined => {
         if (!normalizedChallengeId) {
-            return
+            return undefined
         }
 
-        mutateChallengeResources()
+        return mutateChallengeResources()
             .catch(() => undefined)
     }, [
         mutateChallengeResources,
@@ -1682,6 +1944,153 @@ export const HumanReviewTab: FC = () => {
         ],
     )
 
+    /**
+     * Applies one selected user to every configured Design Challenge screening phase.
+     *
+     * @param selectedMemberId selected member user id, or an empty string when clearing the field.
+     * @returns Nothing; resource mutations continue asynchronously and refresh the resource cache.
+     * @remarks The reviewer form rows are kept aligned with the distinct Screener resources.
+     * Resource failures restore the prior form assignments and surface an inline error.
+     * @throws Does not throw to the input component.
+     */
+    const handleScreenerSelectionChange = useCallback(
+        (selectedMemberId: string): void => {
+            if (
+                isScreenerSyncingRef.current
+                || resourceRolesResult.isLoading
+                || challengeResourcesResult.isLoading
+                || challengeResourcesResult.isError
+                || hasMissingScreenerRole
+                || hasUnresolvedScreenerAssignment
+            ) {
+                return
+            }
+
+            const normalizedSelectedMemberId = normalizeText(selectedMemberId)
+            const previousAssignments = screenerReviewerEntries.map(entry => ({
+                additionalMemberIds: entry.reviewer.additionalMemberIds,
+                fieldIndex: entry.fieldIndex,
+                handle: entry.reviewer.handle,
+                memberId: entry.reviewer.memberId,
+                roleId: entry.reviewer.roleId,
+            }))
+
+            screenerReviewerEntries.forEach(entry => {
+                const targetRoleId = screenerResourceTargets
+                    .find(target => target.roleName === entry.roleName)
+                    ?.roleId
+
+                formContext.setValue(
+                    `reviewers.${entry.fieldIndex}.memberId` as any,
+                    normalizedSelectedMemberId || undefined,
+                    {
+                        shouldDirty: true,
+                        shouldValidate: true,
+                    },
+                )
+                formContext.setValue(
+                    `reviewers.${entry.fieldIndex}.additionalMemberIds` as any,
+                    undefined,
+                    {
+                        shouldDirty: true,
+                        shouldValidate: true,
+                    },
+                )
+                formContext.setValue(
+                    `reviewers.${entry.fieldIndex}.handle` as any,
+                    undefined,
+                    {
+                        shouldDirty: true,
+                        shouldValidate: false,
+                    },
+                )
+
+                if (targetRoleId) {
+                    formContext.setValue(
+                        `reviewers.${entry.fieldIndex}.roleId` as any,
+                        targetRoleId,
+                        {
+                            shouldDirty: true,
+                            shouldValidate: false,
+                        },
+                    )
+                }
+            })
+
+            if (
+                !normalizedChallengeId
+                || !screenerResourceTargets.length
+            ) {
+                return
+            }
+
+            isScreenerSyncingRef.current = true
+            setIsScreenerSyncing(true)
+            syncScreenerResourceAssignments({
+                challengeId: normalizedChallengeId,
+                selectedMemberId: normalizedSelectedMemberId,
+                targets: screenerResourceTargets,
+            })
+                .then(() => refreshChallengeResources())
+                .catch(error => {
+                    previousAssignments.forEach(assignment => {
+                        const reviewerPrefix = `reviewers.${assignment.fieldIndex}`
+
+                        formContext.setValue(
+                            `${reviewerPrefix}.memberId` as any,
+                            assignment.memberId,
+                            {
+                                shouldDirty: true,
+                                shouldValidate: true,
+                            },
+                        )
+                        formContext.setValue(
+                            `${reviewerPrefix}.additionalMemberIds` as any,
+                            assignment.additionalMemberIds,
+                            {
+                                shouldDirty: true,
+                                shouldValidate: true,
+                            },
+                        )
+                        formContext.setValue(
+                            `${reviewerPrefix}.handle` as any,
+                            assignment.handle,
+                            {
+                                shouldDirty: true,
+                                shouldValidate: false,
+                            },
+                        )
+                        formContext.setValue(
+                            `${reviewerPrefix}.roleId` as any,
+                            assignment.roleId,
+                            {
+                                shouldDirty: true,
+                                shouldValidate: false,
+                            },
+                        )
+                    })
+                    handleResourceError(error, 'Failed to update screener assignment')
+                })
+                .finally(() => {
+                    isScreenerSyncingRef.current = false
+                    setIsScreenerSyncing(false)
+                })
+        },
+        [
+            challengeResourcesResult.isError,
+            challengeResourcesResult.isLoading,
+            formContext,
+            handleResourceError,
+            hasMissingScreenerRole,
+            hasUnresolvedScreenerAssignment,
+            normalizedChallengeId,
+            refreshChallengeResources,
+            resourceRolesResult.isLoading,
+            screenerResourceTargets,
+            screenerReviewerEntries,
+        ],
+    )
+
     const syncReviewerScorecardForPhase = useCallback(
         (reviewerIndex: number, reviewer: Reviewer, nextPhaseId: string): void => {
             const fieldIndex = getReviewerFieldIndex(reviewerIndex)
@@ -1938,6 +2347,53 @@ export const HumanReviewTab: FC = () => {
         [handleMemberSelectionChange],
     )
 
+    if (props.screenerOnly) {
+        const isScreenerAssignmentRequired = screenerReviewerEntries.some(entry => (
+            !isScreenerAssignmentOptional(entry.reviewer, phases)
+        ))
+        const isScreenerFieldLoading = resourceRolesResult.isLoading
+            || challengeResourcesResult.isLoading
+        const screenerConfigurationError = !isScreenerFieldLoading && (
+            challengeResourcesResult.isError
+                ? 'Unable to load screener assignments.'
+                : hasUnresolvedScreenerAssignment
+                    ? 'Unable to resolve the current screener assignment.'
+                    : !primaryScreenerReviewerEntry
+                        ? 'Screener configuration is unavailable.'
+                        : hasMissingScreenerRole
+                            ? 'Unable to load all screener roles.'
+                            : undefined
+        )
+
+        return (
+            <div className={styles.screenerOnlyContainer}>
+                {loadError
+                    ? <div className={styles.error}>{loadError}</div>
+                    : undefined}
+                {screenerConfigurationError
+                    ? <div className={styles.error}>{screenerConfigurationError}</div>
+                    : undefined}
+                {primaryScreenerReviewerEntry
+                    ? (
+                        <FormUserAutocomplete
+                            disabled={isScreenerFieldLoading
+                                || isScreenerSyncing
+                                || challengeResourcesResult.isError
+                                || hasMissingScreenerRole
+                                || hasUnresolvedScreenerAssignment}
+                            label='Screener'
+                            name={`reviewers.${primaryScreenerReviewerEntry.fieldIndex}.memberId`}
+                            onValueChange={handleScreenerSelectionChange}
+                            placeholder='Select user'
+                            required={isScreenerAssignmentRequired}
+                            valueField='userId'
+                        />
+                    )
+                    : undefined}
+            </div>
+        )
+    }
+
     return (
         <div className={styles.container}>
             <div className={styles.summary}>
diff --git a/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ReviewersField/ReviewersField.module.scss b/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ReviewersField/ReviewersField.module.scss
index 26f1fc301..ff7e83f40 100644
--- a/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ReviewersField/ReviewersField.module.scss
+++ b/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ReviewersField/ReviewersField.module.scss
@@ -72,6 +72,10 @@
     gap: 16px;
 }
 
+.screenerOnlyContainer {
+    max-width: 420px;
+}
+
 .summary {
     color: #555;
     display: flex;
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 f6593b896..4ae907d2d 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
@@ -29,7 +29,14 @@ jest.mock('../../../../../lib/services', () => ({
 
 jest.mock('./HumanReviewTab', () => ({
     __esModule: true,
-    default: () => <div data-testid='human-review-tab'>Human review content</div>,
+    default: (props: { screenerOnly?: boolean }) => (
+        <div
+            data-screener-only={props.screenerOnly === true ? 'true' : 'false'}
+            data-testid='human-review-tab'
+        >
+            Human review content
+        </div>
+    ),
 }))
 jest.mock('./AiReviewTab', () => ({
     __esModule: true,
@@ -89,11 +96,13 @@ jest.mock('./ReviewContextTab', () => ({
 
 const mockedPatchChallenge = jest.spyOn(services, 'patchChallenge')
     .mockResolvedValue({} as any)
+const mockedFetchAiReviewConfigByChallenge = services.fetchAiReviewConfigByChallenge as jest.Mock
 
 interface TestHarnessProps {
     isReadOnly?: boolean
     numOfSubmissions?: number
     reviewers: Reviewer[]
+    screenerOnly?: boolean
 }
 
 const TestHarness = (props: TestHarnessProps): JSX.Element => {
@@ -107,7 +116,12 @@ const TestHarness = (props: TestHarnessProps): JSX.Element => {
             typeId: 'type-id',
         },
     })
-    const reviewersField = <ReviewersField isReadOnly={props.isReadOnly} />
+    const reviewersField = (
+        <ReviewersField
+            isReadOnly={props.isReadOnly}
+            screenerOnly={props.screenerOnly}
+        />
+    )
 
     return (
         <FormProvider {...formMethods}>
@@ -119,9 +133,33 @@ const TestHarness = (props: TestHarnessProps): JSX.Element => {
 describe('ReviewersField', () => {
     beforeEach(() => {
         jest.clearAllMocks()
+        mockedFetchAiReviewConfigByChallenge.mockResolvedValue(undefined)
         mockedPatchChallenge.mockResolvedValue({} as Challenge)
     })
 
+    it('renders only the screener assignment in editable screener-only mode', () => {
+        render(
+            <TestHarness
+                reviewers={[]}
+                screenerOnly
+            />,
+        )
+
+        expect(screen.getByTestId('human-review-tab')
+            .getAttribute('data-screener-only'))
+            .toBe('true')
+        expect(screen.queryByRole('tablist'))
+            .toBeNull()
+        expect(screen.queryByTestId('ai-review-tab'))
+            .toBeNull()
+        expect(screen.queryByTestId('review-context-tab'))
+            .toBeNull()
+        expect(screen.queryByTestId('review-summary'))
+            .toBeNull()
+        expect(screen.queryByText('Manual review configuration is required.'))
+            .toBeNull()
+    })
+
     it('uses tab labels with reviewer counts and toggles between human and AI content', 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 fc65a2805..3eb5f46b9 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
@@ -42,6 +42,7 @@ type ReviewTab = typeof REVIEW_TAB[number]
 interface ReviewersFieldProps {
     isReadOnly?: boolean
     onConfigSaveControllerReady?: (controller: AiReviewConfigSaveController | undefined) => void
+    screenerOnly?: boolean
 }
 
 function hasReviewerChanges(
@@ -160,10 +161,10 @@ export const ReviewersField: FC<ReviewersFieldProps> = (props: ReviewersFieldPro
         ? `Review Context (${reviewContextRequirementCount})`
         : 'Review Context'
     const aiGatingManualReviewError = useMemo(
-        () => (aiReviewMode !== 'AI_ONLY' && humanReviewersCount === 0
+        () => (!props.screenerOnly && aiReviewMode !== 'AI_ONLY' && humanReviewersCount === 0
             ? 'Manual review configuration is required.'
             : undefined),
-        [aiReviewMode, humanReviewersCount],
+        [aiReviewMode, humanReviewersCount, props.screenerOnly],
     )
 
     useEffect(() => {
@@ -324,7 +325,11 @@ export const ReviewersField: FC<ReviewersFieldProps> = (props: ReviewersFieldPro
                 )
                 : undefined}
 
-            {!props.isReadOnly
+            {!props.isReadOnly && props.screenerOnly
+                ? <HumanReviewTab screenerOnly />
+                : undefined}
+
+            {!props.isReadOnly && !props.screenerOnly
                 ? (
                     <>
                         <div
@@ -395,9 +400,9 @@ export const ReviewersField: FC<ReviewersFieldProps> = (props: ReviewersFieldPro
                         </div>
 
                         <fieldset className={styles.tabPanels}>
-                            {aiGatingManualReviewError && !errors.reviewers && (
-                                <p className={styles.error}>{aiGatingManualReviewError}</p>
-                            )}
+                            {aiGatingManualReviewError && !errors.reviewers
+                                ? <p className={styles.error}>{aiGatingManualReviewError}</p>
+                                : undefined}
                             <div
                                 aria-labelledby='reviewers-human-tab'
                                 className={classNames(

From 86ba781cc282a1aed2b7c59e569a4bfc7e156379 Mon Sep 17 00:00:00 2001
From: Justin Gasper <jmgasper@gmail.com>
Date: Wed, 12 Aug 2026 18:41:21 +1000
Subject: [PATCH 04/13] PM-5787: Allow deferred checkpoint screener assignment

What was broken

The previous PM-5787 changes allowed the standard Screener assignment to be deferred, but an empty Checkpoint Screener assignment still blocked draft saves and launches.

Root cause

The shared optional-assignment helper matched only the exact Screening phase name and explicitly excluded Checkpoint Screening.

What was changed

Extended the optional member-assignment policy to both Screening and Checkpoint Screening while keeping their reviewer configurations and scorecards required. Updated the Challenge Editor documentation to describe both deferred roles.

Any added/updated tests

Updated schema, required-field, save, launch, resource-allocation, and hydration coverage for an unassigned Checkpoint Screener. The four focused suites pass with 124 tests; lint and the production build pass. The full repository run matches the clean dev baseline with 222 passing suites and 18 unrelated failing suites.
---
 .../schemas/challenge-editor.schema.spec.ts   | 11 +++---
 src/apps/work/src/lib/utils/reviewer.utils.ts | 17 +++++----
 .../challenges/ChallengeEditorPage/README.md  |  4 +--
 .../components/ChallengeEditorForm.spec.tsx   | 35 ++++++++++++++----
 .../ReviewersField/HumanReviewTab.spec.tsx    | 36 +++++++++++++++++--
 .../reviewerAssignments.utils.spec.ts         | 16 ++++++++-
 6 files changed, 95 insertions(+), 24 deletions(-)

diff --git a/src/apps/work/src/lib/schemas/challenge-editor.schema.spec.ts b/src/apps/work/src/lib/schemas/challenge-editor.schema.spec.ts
index 0c0203da9..3e21f961c 100644
--- a/src/apps/work/src/lib/schemas/challenge-editor.schema.spec.ts
+++ b/src/apps/work/src/lib/schemas/challenge-editor.schema.spec.ts
@@ -332,11 +332,12 @@ describe('challenge-editor schema reviewer slot assignment validation', () => {
             .toBeTruthy()
     })
 
-    it('still requires an assigned checkpoint screener', async () => {
+    it('accepts an unassigned checkpoint screener for the Checkpoint Screening phase', async () => {
         await expect(
             challengeAdvancedOptionsSchema.validate({
                 ...baseFormData,
                 phases: [{
+                    id: 'checkpoint-screening-phase-instance-id',
                     name: 'Checkpoint Screening',
                     phaseId: 'checkpoint-screening-phase-id',
                 }],
@@ -344,17 +345,15 @@ describe('challenge-editor schema reviewer slot assignment validation', () => {
                     {
                         isMemberReview: true,
                         memberReviewerCount: 1,
-                        phaseId: 'checkpoint-screening-phase-id',
+                        phaseId: 'checkpoint-screening-phase-instance-id',
                         scorecardId: 'checkpoint-screening-scorecard-id',
                         shouldOpenOpportunity: false,
                     },
                 ],
             }),
         )
-            .rejects
-            .toMatchObject({
-                path: 'reviewers[0].memberId',
-            })
+            .resolves
+            .toBeTruthy()
     })
 
     it('accepts required reviewer slot assignments when opportunity is closed', async () => {
diff --git a/src/apps/work/src/lib/utils/reviewer.utils.ts b/src/apps/work/src/lib/utils/reviewer.utils.ts
index 3db86039c..fc1ed2cb2 100644
--- a/src/apps/work/src/lib/utils/reviewer.utils.ts
+++ b/src/apps/work/src/lib/utils/reviewer.utils.ts
@@ -8,7 +8,7 @@ import type {
  *
  * @param value reviewer or phase value to normalize.
  * @returns trimmed text for string values, otherwise an empty string.
- * @remarks Used internally while resolving whether a reviewer belongs to standard Screening.
+ * @remarks Used internally while resolving whether a reviewer belongs to a screening phase.
  * @throws Does not throw.
  */
 function normalizeReviewerValue(value: unknown): string {
@@ -22,9 +22,9 @@ function normalizeReviewerValue(value: unknown): string {
  *
  * @param reviewer reviewer configuration whose phase should be inspected.
  * @param phases challenge phases used to resolve the reviewer's phase name.
- * @returns `true` only for a human reviewer configured on the standard Screening phase.
- * @remarks Form validation and reviewer fields use this exception; Checkpoint Screening and every
- * other reviewer phase still require assignments up front.
+ * @returns `true` for a human reviewer configured on Screening or Checkpoint Screening.
+ * @remarks Form validation and reviewer fields use this exception; every other reviewer phase
+ * still requires assignments up front.
  * @throws Does not throw.
  */
 export function isScreenerAssignmentOptional(
@@ -46,8 +46,13 @@ export function isScreenerAssignmentOptional(
         const matchesPhase = reviewerPhaseId === phaseTemplateId
             || reviewerPhaseId === phaseInstanceId
 
+        const normalizedPhaseName = normalizeReviewerValue(phase.name)
+            .toLowerCase()
+
         return matchesPhase
-            && normalizeReviewerValue(phase.name)
-                .toLowerCase() === 'screening'
+            && (
+                normalizedPhaseName === 'screening'
+                || normalizedPhaseName === 'checkpoint screening'
+            )
     })
 }
diff --git a/src/apps/work/src/pages/challenges/ChallengeEditorPage/README.md b/src/apps/work/src/pages/challenges/ChallengeEditorPage/README.md
index 4f38f5fdf..2df86b530 100644
--- a/src/apps/work/src/pages/challenges/ChallengeEditorPage/README.md
+++ b/src/apps/work/src/pages/challenges/ChallengeEditorPage/README.md
@@ -45,7 +45,7 @@ The form uses `challengeBasicInfoSchema` from `src/apps/work/src/lib/schemas/cha
 - `tags`: optional string array.
 - `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 standard Screening configuration and scorecard remain required, but its Screener member assignment may be left empty until after launch; other closed manual reviewer assignments remain required.
+- `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; 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.
 
 ## Autosave Behavior
@@ -80,7 +80,7 @@ The form uses `challengeBasicInfoSchema` from `src/apps/work/src/lib/schemas/cha
   from `is_test_challenge`, and explicitly persists metadata value `true` or `false`. Test
   challenges do not generate payments, and authorized modifiers can delete them after they reach
   a completed or cancelled status.
-- `ReviewersField`: hidden for `Task` and `Marathon Match` challenges because manual reviewer assignment is handled elsewhere. On the human-review tab, each manual reviewer card keeps the legacy review-type dropdown, backfills missing legacy review-type values from the matching default reviewer or iterative-review phase fallback, and each manual reviewer phase selector hides registration/submission phases and any phase already assigned on another manual reviewer card while preserving the card's current selection. When default reviewer metadata is missing, stale, or already covered by existing rows, `Add reviewer` starts from the next unassigned selectable reviewer phase, preferring review phases before approval or screening phases, so single-round Design schedules add the Approver row instead of a registration/submission or duplicate reviewer row. Manual reviewer counts are capped before rendering member assignment controls so closed public opportunities cannot create an unbounded number of member selectors. Design challenge manual reviewers always keep the public review opportunity checkbox disabled and unchecked. Standard Screening member selectors remain available but are optional so a copilot can assign the Screener after launch.
+- `ReviewersField`: hidden for `Task` and `Marathon Match` challenges because manual reviewer assignment is handled elsewhere. On the human-review tab, each manual reviewer card keeps the legacy review-type dropdown, backfills missing legacy review-type values from the matching default reviewer or iterative-review phase fallback, and each manual reviewer phase selector hides registration/submission phases and any phase already assigned on another manual reviewer card while preserving the card's current selection. When default reviewer metadata is missing, stale, or already covered by existing rows, `Add reviewer` starts from the next unassigned selectable reviewer phase, preferring review phases before approval or screening phases, so single-round Design schedules add the Approver row instead of a registration/submission or duplicate reviewer row. Manual reviewer counts are capped before rendering member assignment controls so closed public opportunities cannot create an unbounded number of member selectors. Design challenge manual reviewers always keep the public review opportunity checkbox disabled and unchecked. Screening and Checkpoint Screening member selectors remain available but are optional so a copilot can assign the Screener or Checkpoint Screener after launch.
 - `Submission Settings`: shown for Design `Challenge` and Design `First2Finish` types, and contains the final-deliverables, stock-art, and submission-limit compatibility fields.
 - `RegisteredMemberDownloadField`: shown in Advanced Options for every created challenge type. The radio group persists `allowAllRegistrantsToDownloadWinningSubmissions` as the exact string `true` for all challenge registrants or `false` for passing submitters only. New Development challenges default to passing submitters; other new challenges, including Design, default to all registrants. Existing challenges without the metadata retain passing-submitter-only access.
 - `FinalDeliverablesField`: design-challenge file-type editor that persists the legacy `fileTypes` metadata payload used on challenge draft pages.
diff --git a/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ChallengeEditorForm.spec.tsx b/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ChallengeEditorForm.spec.tsx
index 19a740abf..04777d84b 100644
--- a/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ChallengeEditorForm.spec.tsx
+++ b/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ChallengeEditorForm.spec.tsx
@@ -858,7 +858,7 @@ describe('ChallengeEditorForm', () => {
         ...validDraftChallenge,
         status: 'NEW',
     } as Challenge
-    const designChallengeWithDeferredScreener = {
+    const designChallengeWithDeferredScreeners = {
         ...validDraftChallenge,
         approvalStatus: 'APPROVED',
         phases: [
@@ -867,6 +867,11 @@ describe('ChallengeEditorForm', () => {
                 name: 'Screening',
                 phaseId: 'screening-phase-id',
             },
+            {
+                duration: 60,
+                name: 'Checkpoint Screening',
+                phaseId: 'checkpoint-screening-phase-id',
+            },
             {
                 duration: 60,
                 name: 'Review',
@@ -882,6 +887,14 @@ describe('ChallengeEditorForm', () => {
                 scorecardId: 'screening-scorecard-id',
                 shouldOpenOpportunity: false,
             },
+            {
+                additionalMemberIds: [],
+                isMemberReview: true,
+                memberReviewerCount: 1,
+                phaseId: 'checkpoint-screening-phase-id',
+                scorecardId: 'checkpoint-screening-scorecard-id',
+                shouldOpenOpportunity: false,
+            },
             {
                 additionalMemberIds: [],
                 isMemberReview: true,
@@ -1912,7 +1925,7 @@ describe('ChallengeEditorForm', () => {
             .not.toHaveBeenCalledWith('Challenge launch is blocked until budget approval is Approved.')
     })
 
-    it('launches a design draft before a screener member is assigned', async () => {
+    it('launches a design draft before screening members are assigned', async () => {
         let launchAction: (() => Promise<void>) | undefined
 
         mockedUseFetchChallengeTracks.mockReturnValue({
@@ -1940,14 +1953,14 @@ describe('ChallengeEditorForm', () => {
             isLoading: false,
         })
         mockedPatchChallenge.mockResolvedValue({
-            ...designChallengeWithDeferredScreener,
+            ...designChallengeWithDeferredScreeners,
             status: 'ACTIVE',
         })
 
         render(
             <MemoryRouter>
                 <ChallengeEditorForm
-                    challenge={designChallengeWithDeferredScreener}
+                    challenge={designChallengeWithDeferredScreeners}
                     isReadOnly
                     onRegisterLaunchAction={action => {
                         launchAction = action
@@ -1973,6 +1986,10 @@ describe('ChallengeEditorForm', () => {
                             phaseId: 'screening-phase-id',
                             scorecardId: 'screening-scorecard-id',
                         }),
+                        expect.objectContaining({
+                            phaseId: 'checkpoint-screening-phase-id',
+                            scorecardId: 'checkpoint-screening-scorecard-id',
+                        }),
                     ]),
                     status: 'ACTIVE',
                 }))
@@ -4203,7 +4220,7 @@ describe('ChallengeEditorForm', () => {
         })
     })
 
-    it('saves a new design draft before a screener member is assigned', async () => {
+    it('saves a new design draft before screening members are assigned', async () => {
         const user = userEvent.setup()
 
         mockedUseFetchChallengeTracks.mockReturnValue({
@@ -4223,7 +4240,7 @@ describe('ChallengeEditorForm', () => {
             isLoading: false,
         })
         mockedPatchChallenge.mockResolvedValue({
-            ...designChallengeWithDeferredScreener,
+            ...designChallengeWithDeferredScreeners,
             status: 'DRAFT',
         })
 
@@ -4231,7 +4248,7 @@ describe('ChallengeEditorForm', () => {
             <MemoryRouter initialEntries={['/projects/100578/challenges/new']}>
                 <ChallengeEditorForm
                     challenge={{
-                        ...designChallengeWithDeferredScreener,
+                        ...designChallengeWithDeferredScreeners,
                         status: 'NEW',
                     }}
                     projectId='100578'
@@ -4250,6 +4267,10 @@ describe('ChallengeEditorForm', () => {
                             phaseId: 'screening-phase-id',
                             scorecardId: 'screening-scorecard-id',
                         }),
+                        expect.objectContaining({
+                            phaseId: 'checkpoint-screening-phase-id',
+                            scorecardId: 'checkpoint-screening-scorecard-id',
+                        }),
                     ]),
                     status: 'DRAFT',
                 }))
diff --git a/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ReviewersField/HumanReviewTab.spec.tsx b/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ReviewersField/HumanReviewTab.spec.tsx
index ee86b0b1f..5fc1479f0 100644
--- a/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ReviewersField/HumanReviewTab.spec.tsx
+++ b/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ReviewersField/HumanReviewTab.spec.tsx
@@ -631,7 +631,7 @@ describe('HumanReviewTab', () => {
         })
     })
 
-    it('keeps a Reviewer resource on Review when Screening has no assigned Screener', async () => {
+    it('keeps a Reviewer resource on Review when screening phases have no assigned screeners', async () => {
         mockedUseFetchResourceRoles.mockReturnValue({
             resourceRoles: [
                 {
@@ -642,6 +642,10 @@ describe('HumanReviewTab', () => {
                     id: 'role-reviewer',
                     name: 'Reviewer',
                 },
+                {
+                    id: 'role-checkpoint-screener',
+                    name: 'Checkpoint Screener',
+                },
             ],
         })
         mockedUseFetchResources.mockReturnValue({
@@ -665,6 +669,11 @@ describe('HumanReviewTab', () => {
                             name: 'Screening',
                             phaseId: 'phase-screening',
                         },
+                        {
+                            id: 'checkpoint-screening-instance',
+                            name: 'Checkpoint Screening',
+                            phaseId: 'phase-checkpoint-screening',
+                        },
                         {
                             id: 'review-instance',
                             name: 'Review',
@@ -679,6 +688,13 @@ describe('HumanReviewTab', () => {
                             phaseId: 'phase-screening',
                             shouldOpenOpportunity: false,
                         },
+                        {
+                            additionalMemberIds: [],
+                            isMemberReview: true,
+                            memberReviewerCount: 1,
+                            phaseId: 'phase-checkpoint-screening',
+                            shouldOpenOpportunity: false,
+                        },
                         {
                             additionalMemberIds: [],
                             isMemberReview: true,
@@ -696,6 +712,9 @@ describe('HumanReviewTab', () => {
                 .getAttribute('data-value'))
                 .toBe('')
             expect(screen.getByTestId('reviewers.1.memberId')
+                .getAttribute('data-value'))
+                .toBe('')
+            expect(screen.getByTestId('reviewers.2.memberId')
                 .getAttribute('data-value'))
                 .toBe('member-reviewer')
         })
@@ -942,7 +961,7 @@ describe('HumanReviewTab', () => {
             .not.toBeNull()
     })
 
-    it('marks only the standard Screening member assignment optional', () => {
+    it('marks Screening and Checkpoint Screening member assignments optional', () => {
         mockedUseFetchChallengeTracks.mockReturnValue({
             tracks: [
                 {
@@ -961,6 +980,10 @@ describe('HumanReviewTab', () => {
                             name: 'Screening',
                             phaseId: 'screening-phase-id',
                         },
+                        {
+                            name: 'Checkpoint Screening',
+                            phaseId: 'checkpoint-screening-phase-id',
+                        },
                         {
                             name: 'Review',
                             phaseId: 'review-phase-id',
@@ -974,6 +997,13 @@ describe('HumanReviewTab', () => {
                             scorecardId: 'screening-scorecard-id',
                             shouldOpenOpportunity: false,
                         },
+                        {
+                            isMemberReview: true,
+                            memberReviewerCount: 1,
+                            phaseId: 'checkpoint-screening-phase-id',
+                            scorecardId: 'checkpoint-screening-scorecard-id',
+                            shouldOpenOpportunity: false,
+                        },
                         {
                             isMemberReview: true,
                             memberReviewerCount: 1,
@@ -989,6 +1019,8 @@ describe('HumanReviewTab', () => {
         expect(screen.getByTestId('reviewers.0.memberId'))
             .toHaveProperty('dataset.required', 'false')
         expect(screen.getByTestId('reviewers.1.memberId'))
+            .toHaveProperty('dataset.required', 'false')
+        expect(screen.getByTestId('reviewers.2.memberId'))
             .toHaveProperty('dataset.required', 'true')
     })
 
diff --git a/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ReviewersField/reviewerAssignments.utils.spec.ts b/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ReviewersField/reviewerAssignments.utils.spec.ts
index fad7ff32c..5fe30605a 100644
--- a/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ReviewersField/reviewerAssignments.utils.spec.ts
+++ b/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ReviewersField/reviewerAssignments.utils.spec.ts
@@ -9,7 +9,7 @@ import {
 } from './reviewerAssignments.utils'
 
 describe('buildAssignedResourcesByReviewer', () => {
-    it('reserves generic reviewer resources for Review rows before Screening fallbacks', () => {
+    it('reserves generic reviewer resources for Review rows before screening phase fallbacks', () => {
         const resourceRoles: ResourceRole[] = [
             {
                 id: 'role-screener',
@@ -19,6 +19,10 @@ describe('buildAssignedResourcesByReviewer', () => {
                 id: 'role-reviewer',
                 name: 'Reviewer',
             },
+            {
+                id: 'role-checkpoint-screener',
+                name: 'Checkpoint Screener',
+            },
         ]
         const resources: Resource[] = [
             {
@@ -33,6 +37,11 @@ describe('buildAssignedResourcesByReviewer', () => {
                 phaseId: 'phase-screening',
                 roleId: 'role-reviewer',
             },
+            {
+                memberReviewerCount: 1,
+                phaseId: 'phase-checkpoint-screening',
+                roleId: 'role-reviewer',
+            },
             {
                 memberReviewerCount: 1,
                 phaseId: 'phase-review',
@@ -45,6 +54,10 @@ describe('buildAssignedResourcesByReviewer', () => {
                     'phase-screening',
                     'Screening',
                 ],
+                [
+                    'phase-checkpoint-screening',
+                    'Checkpoint Screening',
+                ],
                 [
                     'phase-review',
                     'Review',
@@ -58,6 +71,7 @@ describe('buildAssignedResourcesByReviewer', () => {
         expect(assignedResourcesByReviewer.map(assignedResources => assignedResources
             .map(resource => resource.memberHandle)))
             .toEqual([
+                [],
                 [],
                 ['reviewer-one'],
             ])

From c03b5dca9c6b852ecbb9c48e5de487559cd22a79 Mon Sep 17 00:00:00 2001
From: Justin Gasper <jmgasper@gmail.com>
Date: Wed, 12 Aug 2026 19:53:43 +1000
Subject: [PATCH 05/13] PM-5839: Render SFDC payment dates consistently

What was broken

Late July 31 SFDC payments could render as August 1 when the report was viewed from a browser in a positive-offset timezone.

Root cause

The payment table formatted timestamps in the browser's local timezone even though SFDC payment reports use America/New_York calendar dates.

What was changed

Render SFDC payment timestamps explicitly in America/New_York while preserving the existing browser-local formatting for billing-account profile dates.

Any added/updated tests

Added a Reports page regression using the reported July 31 boundary in Asia/Colombo. The test also confirms billing-account profile dates keep their existing formatting.
---
 .../src/pages/reports/ReportsPage.spec.tsx    | 79 ++++++++++++++++++-
 .../reports/src/pages/reports/ReportsPage.tsx | 18 ++++-
 2 files changed, 94 insertions(+), 3 deletions(-)

diff --git a/src/apps/reports/src/pages/reports/ReportsPage.spec.tsx b/src/apps/reports/src/pages/reports/ReportsPage.spec.tsx
index 05dbbfec6..d2f9fd5c7 100644
--- a/src/apps/reports/src/pages/reports/ReportsPage.spec.tsx
+++ b/src/apps/reports/src/pages/reports/ReportsPage.spec.tsx
@@ -17,9 +17,13 @@ import {
     useLocation,
 } from 'react-router-dom'
 
-import { fetchReportsIndex } from '../../lib/services'
+import {
+    fetchReportJson,
+    fetchReportsIndex,
+    SfdcBillingAccountPaymentRow,
+} from '../../lib/services'
 
-import { ReportsPage } from './ReportsPage'
+import { BillingAccountsPage, ReportsPage } from './ReportsPage'
 
 type MockSelectProps = {
     disabled?: boolean
@@ -86,6 +90,8 @@ jest.mock('../../lib/utils', () => ({
 }))
 
 const mockedFetchReportsIndex = fetchReportsIndex as jest.Mock
+const mockedFetchReportJson = fetchReportJson as jest.Mock
+const originalTimezone = process.env.TZ
 
 const LocationProbe = (): JSX.Element => {
     const { pathname }: { pathname: string } = useLocation()
@@ -109,6 +115,15 @@ describe('Reports page navigation', () => {
         })
     })
 
+    afterEach(() => {
+        if (originalTimezone) {
+            process.env.TZ = originalTimezone
+            return
+        }
+
+        delete process.env.TZ
+    })
+
     it('opens Bulk Member Lookup from the Reports app root', async () => {
         render(
             <MemoryRouter initialEntries={['/reports/reports']}>
@@ -137,4 +152,64 @@ describe('Reports page navigation', () => {
         expect(screen.getByTestId('location'))
             .toHaveTextContent('/reports/bulk-member-lookup')
     })
+
+    it('renders SFDC payment dates in America/New_York', async () => {
+        process.env.TZ = 'Asia/Colombo'
+        const paymentDate = '2026-07-31T18:53:33.383-04:00'
+        const payment: SfdcBillingAccountPaymentRow = {
+            billingAccountId: '80000001',
+            category: 'CHALLENGE_PAYMENT',
+            challengeFee: '0.00',
+            challengeId: 'challenge-id',
+            challengeName: 'July payment',
+            challengeStatus: 'Completed',
+            isTask: false,
+            paymentAmount: '100.00',
+            paymentDate,
+            paymentId: 'payment-id',
+            paymentStatus: 'PAID',
+            winnerFirstName: 'Ada',
+            winnerHandle: 'ada',
+            winnerId: '123',
+            winnerLastName: 'Lovelace',
+        }
+        mockedFetchReportJson.mockResolvedValue([payment])
+
+        render(
+            <MemoryRouter initialEntries={['/reports/sfdc-payments']}>
+                <BillingAccountsPage />
+            </MemoryRouter>,
+        )
+
+        expect(await screen.findByText('July payment'))
+            .toBeInTheDocument()
+        const parsedPaymentDate = new Date(paymentDate)
+        const displayedDate = parsedPaymentDate
+            .toLocaleString(undefined, { timeZone: 'America/New_York' })
+        const browserDisplayedDate = parsedPaymentDate
+            .toLocaleString()
+
+        expect(screen.getByText(displayedDate))
+            .toBeInTheDocument()
+        expect(parsedPaymentDate.getUTCDate())
+            .toBe(31)
+        expect(parsedPaymentDate.getDate())
+            .toBe(1)
+        expect(displayedDate)
+            .not.toBe(browserDisplayedDate)
+
+        mockedFetchReportJson.mockResolvedValueOnce({
+            billingAccount: {
+                budget: '1000.00',
+                markup: '0.00',
+                name: 'Boundary account',
+                startDate: paymentDate,
+                status: 'Active',
+            },
+        })
+        fireEvent.click(screen.getByRole('button', { name: '80000001' }))
+
+        expect(await screen.findByText(browserDisplayedDate))
+            .toBeInTheDocument()
+    })
 })
diff --git a/src/apps/reports/src/pages/reports/ReportsPage.tsx b/src/apps/reports/src/pages/reports/ReportsPage.tsx
index eeeecefea..8322afbde 100644
--- a/src/apps/reports/src/pages/reports/ReportsPage.tsx
+++ b/src/apps/reports/src/pages/reports/ReportsPage.tsx
@@ -178,6 +178,22 @@ const formatPaymentDate = (iso: string): string => {
         .toLocaleString()
 }
 
+/**
+ * Formats an SFDC payment timestamp in the report's America/New_York timezone.
+ * The input is an ISO date-time string and the returned value is used in payment table cells.
+ * Invalid inputs are returned unchanged, so this function does not throw parsing errors.
+ */
+const formatSfdcPaymentDate = (iso: string): string => {
+    const parsed = Date.parse(iso)
+
+    if (Number.isNaN(parsed)) {
+        return iso
+    }
+
+    return new Date(parsed)
+        .toLocaleString(undefined, { timeZone: 'America/New_York' })
+}
+
 const PAYMENT_TABLE_COLUMNS: { key: keyof SfdcBillingAccountPaymentRow; label: string }[] = [
     { key: 'paymentId', label: 'Payment ID' },
     { key: 'paymentDate', label: 'Payment date' },
@@ -431,7 +447,7 @@ const BillingAccountReportResults = (
         const value = row[colKey]
 
         if (colKey === 'paymentDate') {
-            return formatPaymentDate(String(value))
+            return formatSfdcPaymentDate(String(value))
         }
 
         if (colKey === 'billingAccountId') {

From 4ea6c825380c22474b9f8596f9af1e0619b80744 Mon Sep 17 00:00:00 2001
From: Justin Gasper <jmgasper@gmail.com>
Date: Wed, 12 Aug 2026 20:43:11 +1000
Subject: [PATCH 06/13] PM-5758: finish design submission limit handling

What was broken
Review showed only the newest submission per member when a Design challenge allowed more than one. Work Manager could also reset the visible submission-limit selection after saving a draft when the save response omitted that metadata entry.

Root cause
Review reduced every finite limit to the API's single isLatest flag and grouped history without using the configured count or exact submission type. The draft editor trusted sparse save-response metadata when resetting the form.

What was changed
Resolve the same latest-X Design policy used by the backend, rank complete member/type history before phase eligibility, and display every eligible Screening and Review row within that window. Preserve unlimited Design behavior and Development's latest-one behavior. Retain the submitted submissionLimit value when a successful draft response omits that entry.

Any added/updated tests
Added and updated regression coverage for finite counts, unlimited and malformed metadata, independent contest/checkpoint histories, rank-before-eligibility, Review row forwarding, Screening selection, and Work Manager draft-save metadata preservation.
---
 .../TabContentReview.spec.tsx                 |  70 +++++++-
 .../TabContentReview.tsx                      |  16 +-
 .../TabContentSubmissions.tsx                 |  11 +-
 .../components/TableReview/TableReview.tsx    |  18 +-
 .../TableReviewForSubmitter.tsx               |  13 +-
 .../TableSubmissionScreening.tsx              |  30 ++--
 .../src/lib/hooks/useSubmissionHistory.ts     |  24 ++-
 .../review/src/lib/utils/challenge.spec.ts    | 110 ++++++++++++
 src/apps/review/src/lib/utils/challenge.ts    | 149 +++++++++++++++-
 .../src/lib/utils/screeningRows.spec.ts       |  82 ++++-----
 .../review/src/lib/utils/screeningRows.ts     |  23 +--
 .../src/lib/utils/submissionHistory.spec.ts   | 119 +++++++++++++
 .../review/src/lib/utils/submissionHistory.ts | 160 +++++++++++++-----
 .../challenges/ChallengeEditorPage/README.md  |   2 +-
 .../components/ChallengeEditorForm.spec.tsx   |  69 ++++++++
 .../components/ChallengeEditorForm.tsx        |  26 ++-
 16 files changed, 773 insertions(+), 149 deletions(-)
 create mode 100644 src/apps/review/src/lib/utils/submissionHistory.spec.ts

diff --git a/src/apps/review/src/lib/components/ChallengeDetailsContent/TabContentReview.spec.tsx b/src/apps/review/src/lib/components/ChallengeDetailsContent/TabContentReview.spec.tsx
index 665c3ec19..f9e4385db 100644
--- a/src/apps/review/src/lib/components/ChallengeDetailsContent/TabContentReview.spec.tsx
+++ b/src/apps/review/src/lib/components/ChallengeDetailsContent/TabContentReview.spec.tsx
@@ -15,6 +15,7 @@ import { TabContentReview } from './TabContentReview'
 const mockUseRole = jest.fn()
 const mockTableAppealsForSubmitter = jest.fn()
 const mockTableAppealsResponse = jest.fn()
+const mockTableReview = jest.fn()
 const mockTableReviewForSubmitter = jest.fn()
 
 jest.mock('~/config', () => ({
@@ -78,7 +79,15 @@ jest.mock('../TableNoRecord', () => ({
 }))
 
 jest.mock('../TableReview', () => ({
-    TableReview: () => <div>Reviewer reviews</div>,
+    TableReview: (props: { datas: SubmissionInfo[] }) => {
+        mockTableReview(props)
+        return (
+            <div>
+                {props.datas.map(submission => submission.id)
+                    .join(',')}
+            </div>
+        )
+    },
 }))
 
 jest.mock('../TableReviewForSubmitter', () => ({
@@ -208,4 +217,63 @@ describe('TabContentReview submitter Appeals ownership', () => {
                 ],
             }))
     })
+
+    it('passes both finite-limit Design reviews for one member to the reviewer table', () => {
+        const olderSubmission = {
+            id: 'member-submission-older',
+            isLatest: false,
+            memberId: 'member-shared',
+            review: {
+                phaseName: 'Review',
+                reviewType: 'Review',
+            },
+            submittedDate: '2026-08-12T10:00:00Z',
+            type: 'CONTEST_SUBMISSION',
+        } as SubmissionInfo
+        const latestSubmission = {
+            ...olderSubmission,
+            id: 'member-submission-latest',
+            isLatest: true,
+            submittedDate: '2026-08-12T11:00:00Z',
+        }
+        const reviewerChallengeInfo = {
+            ...challengeInfo,
+            metadata: [{
+                name: 'submissionLimit',
+                value: JSON.stringify({ count: '2', limit: 'true', unlimited: 'false' }),
+            }],
+            submissions: [olderSubmission, latestSubmission],
+            track: {
+                id: 'design-track',
+                name: 'Design',
+            },
+        } as ChallengeInfo
+        const reviewerContext = {
+            ...challengeContext,
+            challengeInfo: reviewerChallengeInfo,
+            myResources: [],
+            myRoles: ['Reviewer'],
+        } as unknown as ChallengeDetailContextModel
+        mockUseRole.mockReturnValue({
+            actionChallengeRole: 'Reviewer',
+            hasApproverRole: false,
+            isPrivilegedRole: true,
+        })
+
+        render(
+            <ChallengeDetailContext.Provider value={reviewerContext}>
+                <TabContentReview
+                    {...commonProps}
+                    isActiveChallenge
+                    reviews={[olderSubmission, latestSubmission]}
+                    selectedTab='Review'
+                />
+            </ChallengeDetailContext.Provider>,
+        )
+
+        expect(mockTableReview)
+            .toHaveBeenLastCalledWith(expect.objectContaining({
+                datas: [olderSubmission, latestSubmission],
+            }))
+    })
 })
diff --git a/src/apps/review/src/lib/components/ChallengeDetailsContent/TabContentReview.tsx b/src/apps/review/src/lib/components/ChallengeDetailsContent/TabContentReview.tsx
index 41e5ae051..46bbebb96 100644
--- a/src/apps/review/src/lib/components/ChallengeDetailsContent/TabContentReview.tsx
+++ b/src/apps/review/src/lib/components/ChallengeDetailsContent/TabContentReview.tsx
@@ -770,23 +770,23 @@ export const TabContentReview: FC<Props> = (props: Props) => {
     )
     const reviewerRowsForReviewTab = useMemo(
         () => (shouldSortReviewTabByScore
-            ? sortSubmissionsByReviewScoreDesc(filteredReviews, useAggregateReviewScore)
-            : filteredReviews),
-        [filteredReviews, shouldSortReviewTabByScore, useAggregateReviewScore],
+            ? sortSubmissionsByReviewScoreDesc(resolvedReviewsWithSubmitter, useAggregateReviewScore)
+            : resolvedReviewsWithSubmitter),
+        [resolvedReviewsWithSubmitter, shouldSortReviewTabByScore, useAggregateReviewScore],
     )
     const submitterRowsForReviewTab = useMemo(
         () => (shouldSortReviewTabByScore
-            ? sortSubmissionsByReviewScoreDesc(filteredSubmitterReviews, useAggregateReviewScore)
-            : filteredSubmitterReviews),
-        [filteredSubmitterReviews, shouldSortReviewTabByScore, useAggregateReviewScore],
+            ? sortSubmissionsByReviewScoreDesc(resolvedSubmitterReviews, useAggregateReviewScore)
+            : resolvedSubmitterReviews),
+        [resolvedSubmitterReviews, shouldSortReviewTabByScore, useAggregateReviewScore],
     )
     const hideHandleColumn = props.isActiveChallenge
         && actionChallengeRole === REVIEWER
 
     // show loading ui when fetching data
     const reviewRows = isSubmitterView
-        ? (shouldSortReviewTabByScore ? submitterRowsForReviewTab : filteredSubmitterReviews)
-        : (shouldSortReviewTabByScore ? reviewerRowsForReviewTab : filteredReviews)
+        ? submitterRowsForReviewTab
+        : reviewerRowsForReviewTab
 
     if (props.isLoadingReview) {
         return <TableLoading />
diff --git a/src/apps/review/src/lib/components/ChallengeDetailsContent/TabContentSubmissions.tsx b/src/apps/review/src/lib/components/ChallengeDetailsContent/TabContentSubmissions.tsx
index 536480f4e..657488568 100644
--- a/src/apps/review/src/lib/components/ChallengeDetailsContent/TabContentSubmissions.tsx
+++ b/src/apps/review/src/lib/components/ChallengeDetailsContent/TabContentSubmissions.tsx
@@ -204,7 +204,8 @@ export const TabContentSubmissions: FC<Props> = props => {
                 return
             }
 
-            const key = getSubmissionHistoryKey(memberId, submissionId)
+            const submissionType = submissionInfoById.get(submissionId)?.type
+            const key = getSubmissionHistoryKey(memberId, submissionId, submissionType)
             const entries = historyByMember.get(key) ?? []
             if (!entries.length) {
                 return
@@ -212,7 +213,7 @@ export const TabContentSubmissions: FC<Props> = props => {
 
             setHistoryKey(key)
         },
-        [historyByMember],
+        [historyByMember, submissionInfoById],
     )
 
     const handleHistoryButtonClick = useCallback(
@@ -524,7 +525,11 @@ export const TabContentSubmissions: FC<Props> = props => {
                             return <span>-</span>
                         }
 
-                        const key = getSubmissionHistoryKey(submission.memberId, submission.id)
+                        const key = getSubmissionHistoryKey(
+                            submission.memberId,
+                            submission.id,
+                            submission.type,
+                        )
                         const historyEntries = historyByMember.get(key) ?? []
                         if (!historyEntries.length) {
                             return <span>-</span>
diff --git a/src/apps/review/src/lib/components/TableReview/TableReview.tsx b/src/apps/review/src/lib/components/TableReview/TableReview.tsx
index fec6728bc..a06faab00 100644
--- a/src/apps/review/src/lib/components/TableReview/TableReview.tsx
+++ b/src/apps/review/src/lib/components/TableReview/TableReview.tsx
@@ -41,7 +41,7 @@ import {
 } from '../../models'
 import {
     aggregateSubmissionReviews,
-    challengeHasSubmissionLimit,
+    getChallengeSubmissionSelectionLimit,
     isMarathonMatchChallenge,
     isReviewPhase,
     isReviewPhaseCurrentlyOpen,
@@ -180,6 +180,11 @@ export const TableReview: FC<TableReviewProps> = (props: TableReviewProps) => {
         [challengeInfo, submissionTypes],
     )
 
+    const submissionSelectionLimit = useMemo<number | undefined>(
+        () => getChallengeSubmissionSelectionLimit(challengeInfo),
+        [challengeInfo],
+    )
+
     const {
         closeHistoryModal,
         historyByMember,
@@ -193,11 +198,12 @@ export const TableReview: FC<TableReviewProps> = (props: TableReviewProps) => {
         datas: reviewPhaseDatas,
         filteredAll: filteredChallengeSubmissions,
         isSubmissionTab: true,
+        maxVisibleSubmissions: submissionSelectionLimit,
     })
 
     const restrictToLatest = useMemo<boolean>(
-        () => challengeHasSubmissionLimit(challengeInfo),
-        [challengeInfo],
+        () => submissionSelectionLimit !== undefined,
+        [submissionSelectionLimit],
     )
     const useAggregateReviewScore = useMemo<boolean>(
         () => isMarathonMatchChallenge(challengeInfo),
@@ -650,7 +656,11 @@ export const TableReview: FC<TableReviewProps> = (props: TableReviewProps) => {
             )
         }
 
-        const historyKeyForRow = getSubmissionHistoryKey(submission.memberId, submission.id)
+        const historyKeyForRow = getSubmissionHistoryKey(
+            submission.memberId,
+            submission.id,
+            submission.type,
+        )
         const rowHistory = historyByMember.get(historyKeyForRow) ?? []
 
         const buildHistoryAction = (): JSX.Element | undefined => {
diff --git a/src/apps/review/src/lib/components/TableReviewForSubmitter/TableReviewForSubmitter.tsx b/src/apps/review/src/lib/components/TableReviewForSubmitter/TableReviewForSubmitter.tsx
index bd6aad00d..cfe24785b 100644
--- a/src/apps/review/src/lib/components/TableReviewForSubmitter/TableReviewForSubmitter.tsx
+++ b/src/apps/review/src/lib/components/TableReviewForSubmitter/TableReviewForSubmitter.tsx
@@ -40,7 +40,7 @@ import type {
 } from '../common/types'
 import {
     aggregateSubmissionReviews,
-    challengeHasSubmissionLimit,
+    getChallengeSubmissionSelectionLimit,
     getSubmissionHistoryKey,
     isAppealsPhase,
     isAppealsResponsePhase,
@@ -155,6 +155,11 @@ export const TableReviewForSubmitter: FC<TableReviewForSubmitterProps> = (props:
         [challengeInfo?.submissions, datas, submissionTypes],
     )
 
+    const submissionSelectionLimit = useMemo<number | undefined>(
+        () => getChallengeSubmissionSelectionLimit(challengeInfo),
+        [challengeInfo],
+    )
+
     const {
         closeHistoryModal,
         historyByMember,
@@ -168,11 +173,12 @@ export const TableReviewForSubmitter: FC<TableReviewForSubmitterProps> = (props:
         datas,
         filteredAll,
         isSubmissionTab: true,
+        maxVisibleSubmissions: submissionSelectionLimit,
     })
 
     const restrictToLatest = useMemo<boolean>(
-        () => challengeHasSubmissionLimit(challengeInfo),
-        [challengeInfo],
+        () => submissionSelectionLimit !== undefined,
+        [submissionSelectionLimit],
     )
     const useAggregateReviewScore = useMemo<boolean>(
         () => isMarathonMatchChallenge(challengeInfo),
@@ -524,6 +530,7 @@ export const TableReviewForSubmitter: FC<TableReviewForSubmitterProps> = (props:
                     const historyKeyForSubmission = getSubmissionHistoryKey(
                         submission.memberId,
                         submission.id,
+                        submission.type,
                     )
                     const historyEntries = historyByMember.get(historyKeyForSubmission) ?? []
                     const filteredHistory = restrictToLatest
diff --git a/src/apps/review/src/lib/components/TableSubmissionScreening/TableSubmissionScreening.tsx b/src/apps/review/src/lib/components/TableSubmissionScreening/TableSubmissionScreening.tsx
index 62f4617fd..512ce4dee 100644
--- a/src/apps/review/src/lib/components/TableSubmissionScreening/TableSubmissionScreening.tsx
+++ b/src/apps/review/src/lib/components/TableSubmissionScreening/TableSubmissionScreening.tsx
@@ -33,7 +33,7 @@ import {
 import { TableWrapper } from '../TableWrapper'
 import { SubmissionHistoryModal } from '../SubmissionHistoryModal'
 import {
-    challengeHasSubmissionLimit,
+    getChallengeSubmissionSelectionLimit,
     getHandleUrl,
     getSubmissionHistoryKey,
     isReviewPhaseCurrentlyOpen,
@@ -400,7 +400,11 @@ const createHistoryAction = ({
         return undefined
     }
 
-    const historyKeyForRow = getSubmissionHistoryKey(data.memberId, data.submissionId)
+    const historyKeyForRow = getSubmissionHistoryKey(
+        data.memberId,
+        data.submissionId,
+        data.type,
+    )
     const historyEntries = historyByMember.get(historyKeyForRow) ?? []
     if (!historyEntries.length) {
         return undefined
@@ -945,9 +949,16 @@ export const TableSubmissionScreening: FC<Props> = (props: Props) => {
         [submissionMetaById],
     )
 
+    const submissionSelectionLimit = useMemo<number | undefined>(
+        () => getChallengeSubmissionSelectionLimit(challengeInfo),
+        [challengeInfo],
+    )
+
     const submissionHistory = useMemo(
-        () => partitionSubmissionHistory(primarySubmissionInfos, historySourceSubmissions),
-        [historySourceSubmissions, primarySubmissionInfos],
+        () => partitionSubmissionHistory(primarySubmissionInfos, historySourceSubmissions, {
+            visibleSubmissionCount: submissionSelectionLimit,
+        }),
+        [historySourceSubmissions, primarySubmissionInfos, submissionSelectionLimit],
     )
 
     const { historyByMember, latestSubmissionIds }: SubmissionHistoryPartition = submissionHistory
@@ -957,16 +968,14 @@ export const TableSubmissionScreening: FC<Props> = (props: Props) => {
         rows: visibleScreenings,
     }: ScreeningRowsSelection = useMemo(
         () => selectVisibleScreeningRows({
-            hasSubmissionLimit: challengeHasSubmissionLimit(challengeInfo),
             latestSubmissionIds,
             screeningRows: props.screenings,
-            submissionInfos: primarySubmissionInfos,
+            submissionLimit: submissionSelectionLimit,
         }),
         [
-            challengeInfo,
             latestSubmissionIds,
-            primarySubmissionInfos,
             props.screenings,
+            submissionSelectionLimit,
         ],
     )
 
@@ -1051,7 +1060,8 @@ export const TableSubmissionScreening: FC<Props> = (props: Props) => {
 
     const openHistoryModal = useCallback(
         (memberId: string | undefined, submissionId: string): void => {
-            const key = getSubmissionHistoryKey(memberId, submissionId)
+            const submissionType = submissionMetaById.get(submissionId)?.type
+            const key = getSubmissionHistoryKey(memberId, submissionId, submissionType)
             const historyEntries = historyByMember.get(key)
             if (!historyEntries || historyEntries.length === 0) {
                 return
@@ -1059,7 +1069,7 @@ export const TableSubmissionScreening: FC<Props> = (props: Props) => {
 
             setHistoryKey(key)
         },
-        [historyByMember],
+        [historyByMember, submissionMetaById],
     )
 
     const openReopenDialog = useCallback(
diff --git a/src/apps/review/src/lib/hooks/useSubmissionHistory.ts b/src/apps/review/src/lib/hooks/useSubmissionHistory.ts
index 649265df0..e318f039d 100644
--- a/src/apps/review/src/lib/hooks/useSubmissionHistory.ts
+++ b/src/apps/review/src/lib/hooks/useSubmissionHistory.ts
@@ -9,9 +9,14 @@ import {
 import type { SubmissionHistoryPartition } from '../utils/submissionHistory'
 
 interface UseSubmissionHistoryParams {
+    /** Primary table submissions, including review or screening details. */
     datas: SubmissionInfo[]
+    /** Complete matching challenge history used to rank submissions. */
     filteredAll: SubmissionInfo[]
+    /** Whether the consuming table supports submission-history actions. */
     isSubmissionTab: boolean
+    /** Positive latest-submission count per member/type group. Defaults to one. */
+    maxVisibleSubmissions?: number
 }
 
 export interface UseSubmissionHistoryResult {
@@ -26,16 +31,23 @@ export interface UseSubmissionHistoryResult {
 }
 
 /**
- * Encapsulates submission history modal state and derived metadata for tables.
+ * Encapsulate submission-history ranking and modal state for Review tables.
+ *
+ * @param params - Primary rows, complete matching history, table mode, and visible count.
+ * @returns Latest selected rows and IDs, older member/type history, and modal callbacks.
+ * @throws Does not throw; invalid visible counts are normalized by the partition utility.
  */
 export function useSubmissionHistory({
     datas,
     filteredAll,
     isSubmissionTab,
+    maxVisibleSubmissions,
 }: UseSubmissionHistoryParams): UseSubmissionHistoryResult {
     const submissionHistory = useMemo<SubmissionHistoryPartition>(
-        () => partitionSubmissionHistory(datas, filteredAll),
-        [datas, filteredAll],
+        () => partitionSubmissionHistory(datas, filteredAll, {
+            visibleSubmissionCount: maxVisibleSubmissions,
+        }),
+        [datas, filteredAll, maxVisibleSubmissions],
     )
 
     const {
@@ -58,7 +70,9 @@ export function useSubmissionHistory({
 
     const openHistoryModal: (memberId: string | undefined, submissionId: string) => void = useCallback(
         (memberId: string | undefined, submissionId: string): void => {
-            const key = getSubmissionHistoryKey(memberId, submissionId)
+            const submissionType = datas.find(submission => submission.id === submissionId)?.type
+                ?? filteredAll.find(submission => submission.id === submissionId)?.type
+            const key = getSubmissionHistoryKey(memberId, submissionId, submissionType)
             const entries = historyByMember.get(key)
             if (!entries || entries.length === 0) {
                 return
@@ -66,7 +80,7 @@ export function useSubmissionHistory({
 
             setHistoryKey(key)
         },
-        [historyByMember],
+        [datas, filteredAll, historyByMember],
     )
 
     const closeHistoryModal = useCallback((): void => {
diff --git a/src/apps/review/src/lib/utils/challenge.spec.ts b/src/apps/review/src/lib/utils/challenge.spec.ts
index b6c48380a..39f52fb24 100644
--- a/src/apps/review/src/lib/utils/challenge.spec.ts
+++ b/src/apps/review/src/lib/utils/challenge.spec.ts
@@ -4,6 +4,7 @@ import {
     buildPhaseTabs,
     collectReopenEligiblePhaseIds,
     findPhaseByTabLabel,
+    getChallengeSubmissionSelectionLimit,
     hasPendingApprovalReview,
     isFirst2FinishChallenge,
     isMarathonMatchChallenge,
@@ -51,6 +52,115 @@ const createBackendPhase = (
 })
 
 describe('challenge phase tab helpers', () => {
+    it('uses the configured Design submission count', () => {
+        expect(getChallengeSubmissionSelectionLimit({
+            metadata: [{
+                name: 'submissionLimit',
+                value: JSON.stringify({ count: '2', limit: 'true', unlimited: 'false' }),
+            }],
+            track: {
+                id: 'design-track',
+                name: 'Design',
+            },
+        }))
+            .toBe(2)
+    })
+
+    it('retains the latest-one policy for a finite Design count of one', () => {
+        expect(getChallengeSubmissionSelectionLimit({
+            metadata: [{
+                name: 'submissionLimit',
+                value: JSON.stringify({ count: 1, limit: true, unlimited: false }),
+            }],
+            track: {
+                id: 'design-track',
+                name: 'Design',
+            },
+        }))
+            .toBe(1)
+    })
+
+    it('keeps explicit and default Design submission limits unlimited', () => {
+        const track = {
+            id: 'design-track',
+            name: 'Design',
+        }
+
+        expect(getChallengeSubmissionSelectionLimit({ metadata: [], track }))
+            .toBeUndefined()
+        expect(getChallengeSubmissionSelectionLimit({
+            metadata: [{
+                name: 'submissionLimit',
+                value: JSON.stringify({ count: '', limit: 'false', unlimited: 'true' }),
+            }],
+            track,
+        }))
+            .toBeUndefined()
+    })
+
+    it('recognizes Design from canonical track fields and keeps non-Design latest-one', () => {
+        expect(getChallengeSubmissionSelectionLimit({
+            metadata: [],
+            track: {
+                id: 'design-track',
+                name: '',
+                track: 'DESIGN',
+            },
+        }))
+            .toBeUndefined()
+        expect(getChallengeSubmissionSelectionLimit({
+            metadata: [{
+                name: 'submissionLimit',
+                value: JSON.stringify({ count: '', limit: 'false', unlimited: 'true' }),
+            }],
+            track: {
+                id: 'development-track',
+                name: 'Development',
+            },
+        }))
+            .toBe(1)
+    })
+
+    it.each([
+        [
+            'an explicit unlimited flag with a stale count',
+            { count: '5', limit: 'false' },
+            undefined,
+        ],
+        [
+            'contradictory flags',
+            { count: '2', limit: 'true', unlimited: 'true' },
+            1,
+        ],
+        [
+            'a non-integer count',
+            '2.5',
+            1,
+        ],
+        [
+            'an invalid higher-priority count alias',
+            { count: 'invalid', maximum: '4' },
+            1,
+        ],
+        [
+            'an unrecognized boolean flag alias with a valid count',
+            { count: '3', limit: 'unlimited' },
+            3,
+        ],
+    ])('matches the backend policy for %s', (_description, value, expected) => {
+        expect(getChallengeSubmissionSelectionLimit({
+            metadata: [{
+                name: 'submissionLimit',
+                value: typeof value === 'string' ? value : JSON.stringify(value),
+            }],
+            track: {
+                id: 'design-track',
+                name: 'Design',
+            },
+        }))
+            .toBe(expected)
+    })
+
     it('recognizes Marathon Match challenges from type metadata', () => {
         expect(isMarathonMatchChallenge({
             type: {
diff --git a/src/apps/review/src/lib/utils/challenge.ts b/src/apps/review/src/lib/utils/challenge.ts
index df58c44b9..31dceb290 100644
--- a/src/apps/review/src/lib/utils/challenge.ts
+++ b/src/apps/review/src/lib/utils/challenge.ts
@@ -54,6 +54,13 @@ export function isAppealsResponsePhase(challengeInfo?: ChallengeInfo): boolean {
 }
 
 const SUBMISSION_LIMIT_KEY = 'submissionlimit'
+const SUBMISSION_LIMIT_COUNT_FIELDS = [
+    'count',
+    'max',
+    'maximum',
+    'limitCount',
+    'value',
+] as const
 const UNLIMITED_KEYWORDS = ['unlimited', 'false', '0', 'no', 'none']
 const TRUE_KEYWORDS = ['true', 'yes', '1']
 
@@ -87,6 +94,39 @@ function parseBooleanFlag(value: unknown): boolean | undefined {
     return undefined
 }
 
+/**
+ * Parse submission-limit object flags using the backend's accepted boolean aliases.
+ *
+ * @param value - Raw `limit` or `unlimited` flag.
+ * @returns The recognized boolean value, or `undefined` for malformed aliases.
+ * @throws Does not throw.
+ */
+function parseSubmissionLimitFlag(value: unknown): boolean | undefined {
+    if (typeof value === 'boolean') {
+        return value
+    }
+
+    if (value === 1 || value === 0) {
+        return value === 1
+    }
+
+    if (typeof value !== 'string') {
+        return undefined
+    }
+
+    const normalized = value.trim()
+        .toLowerCase()
+    if (TRUE_KEYWORDS.includes(normalized)) {
+        return true
+    }
+
+    if (['false', 'no', '0'].includes(normalized)) {
+        return false
+    }
+
+    return undefined
+}
+
 function hasPositiveNumeric(value: unknown): boolean {
     if (value === undefined || value === null) {
         return false
@@ -171,7 +211,16 @@ function evaluateObjectLimit(candidate: Record<string, unknown>): boolean {
     return true
 }
 
-export function challengeHasSubmissionLimit(challengeInfo?: ChallengeInfo): boolean {
+/**
+ * Determine whether legacy submission-limit metadata represents a finite limit.
+ *
+ * @param challengeInfo - Challenge metadata containing the legacy `submissionLimit` entry.
+ * @returns True for finite or malformed legacy values and false for explicit unlimited values.
+ * @throws Does not throw; missing metadata retains the legacy finite-limit fallback.
+ */
+export function challengeHasSubmissionLimit(
+    challengeInfo?: Pick<ChallengeInfo, 'metadata'>,
+): boolean {
     const rawValue = findSubmissionLimitMetadata(challengeInfo?.metadata)
     if (rawValue === undefined || rawValue === null) {
         return true
@@ -198,6 +247,104 @@ export function challengeHasSubmissionLimit(challengeInfo?: ChallengeInfo): bool
     return true
 }
 
+/**
+ * Convert a numeric metadata value to a safe positive-integer submission count.
+ *
+ * @param value - Raw count value from challenge metadata.
+ * @returns The positive whole-number count, or `undefined` when the value is not positive numeric data.
+ * @throws Does not throw; invalid values are ignored.
+ */
+function parsePositiveSubmissionLimit(value: unknown): number | undefined {
+    if (typeof value !== 'number' && typeof value !== 'string') {
+        return undefined
+    }
+
+    const numericValue = Number(value)
+    return Number.isSafeInteger(numericValue) && numericValue > 0
+        ? numericValue
+        : undefined
+}
+
+/**
+ * Resolve how many submissions per member and exact submission type Review should display.
+ *
+ * Design challenges with missing or explicit unlimited metadata keep every submission visible;
+ * a positive configured count selects that many. Flag conflicts, invalid counts, malformed Design
+ * data, and all non-Design challenges retain the existing latest-one behavior. Explicit unlimited
+ * flags take precedence over stale counts. These rules mirror the backend selection policy so the
+ * UI displays the same submission set for which scorecards were created.
+ *
+ * @param challengeInfo - Challenge track and submission-limit metadata.
+ * @returns A positive latest-submission count, or `undefined` when every submission is visible.
+ * @throws Does not throw; malformed limited Design metadata falls back to one.
+ */
+export function getChallengeSubmissionSelectionLimit(
+    challengeInfo?: Pick<ChallengeInfo, 'metadata' | 'track'>,
+): number | undefined {
+    const trackCandidates = [
+        challengeInfo?.track?.name,
+        challengeInfo?.track?.abbreviation,
+        challengeInfo?.track?.track,
+    ]
+    const isDesignChallenge = trackCandidates.some(candidate => (
+        normalizeChallengeKey(candidate) === 'design'
+    ))
+    if (!isDesignChallenge) {
+        return 1
+    }
+
+    const rawValue = findSubmissionLimitMetadata(challengeInfo?.metadata)
+    if (rawValue === undefined || rawValue === null) {
+        return undefined
+    }
+
+    const normalized = normalizeLimitMetadataValue(rawValue)
+    const primitiveLimit = parsePositiveSubmissionLimit(normalized)
+    if (primitiveLimit !== undefined) {
+        return primitiveLimit
+    }
+
+    if (typeof normalized === 'number' && normalized === 0) {
+        return undefined
+    }
+
+    if (typeof normalized === 'boolean') {
+        return normalized ? 1 : undefined
+    }
+
+    if (typeof normalized === 'string') {
+        return UNLIMITED_KEYWORDS.includes(normalized.trim()
+            .toLowerCase())
+            ? undefined
+            : 1
+    }
+
+    if (normalized && typeof normalized === 'object' && !Array.isArray(normalized)) {
+        const candidate = normalized as Record<string, unknown>
+        const unlimitedFlag = parseSubmissionLimitFlag(candidate.unlimited)
+        const limitFlag = parseSubmissionLimitFlag(candidate.limit)
+        const countValue = SUBMISSION_LIMIT_COUNT_FIELDS
+            .map(fieldName => candidate[fieldName])
+            .find(value => value !== undefined && value !== null && value !== '')
+        const count = parsePositiveSubmissionLimit(countValue)
+        const flagsConflict = unlimitedFlag !== undefined
+            && limitFlag !== undefined
+            && unlimitedFlag === limitFlag
+
+        if (flagsConflict) {
+            return 1
+        }
+
+        if (unlimitedFlag === true || limitFlag === false) {
+            return undefined
+        }
+
+        return count ?? 1
+    }
+
+    return 1
+}
+
 export type PhaseLike = Pick<
     BackendPhase,
     | 'id'
diff --git a/src/apps/review/src/lib/utils/screeningRows.spec.ts b/src/apps/review/src/lib/utils/screeningRows.spec.ts
index 101982820..1ac1f3c22 100644
--- a/src/apps/review/src/lib/utils/screeningRows.spec.ts
+++ b/src/apps/review/src/lib/utils/screeningRows.spec.ts
@@ -1,47 +1,21 @@
-import type { Screening, SubmissionInfo } from '../models'
+import type { Screening } from '../models'
 
 import { selectVisibleScreeningRows } from './screeningRows'
 
 const screeningRows = [
-    { submissionId: 'member-one-old' },
+    { submissionId: 'member-one-oldest' },
+    { submissionId: 'member-one-middle' },
     { submissionId: 'member-one-latest' },
-    { submissionId: 'member-two-old' },
+    { submissionId: 'member-two-oldest' },
+    { submissionId: 'member-two-middle' },
     { submissionId: 'member-two-latest' },
 ] as Screening[]
 
-const latestSubmissionIds = new Set([
-    'member-one-latest',
-    'member-two-latest',
-])
-
 describe('selectVisibleScreeningRows', () => {
-    it('retains every row for an unlimited challenge without latest flags', () => {
-        const result = selectVisibleScreeningRows({
-            hasSubmissionLimit: false,
-            latestSubmissionIds,
-            screeningRows,
-            submissionInfos: [{}, {}, {}, {}],
-        })
-
-        expect(result.isRestrictedToLatest)
-            .toBe(false)
-        expect(result.rows)
-            .toBe(screeningRows)
-    })
-
-    it('retains every row for an unlimited challenge with stale latest flags', () => {
-        const submissionInfos: Array<Pick<SubmissionInfo, 'isLatest'>> = [
-            { isLatest: false },
-            { isLatest: true },
-            { isLatest: false },
-            { isLatest: true },
-        ]
-
+    it('retains every row for an unlimited challenge', () => {
         const result = selectVisibleScreeningRows({
-            hasSubmissionLimit: false,
-            latestSubmissionIds,
+            latestSubmissionIds: new Set(),
             screeningRows,
-            submissionInfos,
         })
 
         expect(result.isRestrictedToLatest)
@@ -50,41 +24,45 @@ describe('selectVisibleScreeningRows', () => {
             .toBe(screeningRows)
     })
 
-    it('retains every row for a limited challenge without explicit latest flags', () => {
+    it('retains the latest two selected rows per member for a finite count of two', () => {
         const result = selectVisibleScreeningRows({
-            hasSubmissionLimit: true,
-            latestSubmissionIds,
+            latestSubmissionIds: new Set([
+                'member-one-middle',
+                'member-one-latest',
+                'member-two-middle',
+                'member-two-latest',
+            ]),
             screeningRows,
-            submissionInfos: [{}, {}, {}, {}],
+            submissionLimit: 2,
         })
 
         expect(result.isRestrictedToLatest)
-            .toBe(false)
+            .toBe(true)
         expect(result.rows)
-            .toBe(screeningRows)
+            .toEqual([
+                screeningRows[1],
+                screeningRows[2],
+                screeningRows[4],
+                screeningRows[5],
+            ])
     })
 
-    it('retains only explicit latest submissions for a limited challenge', () => {
-        const submissionInfos: Array<Pick<SubmissionInfo, 'isLatest'>> = [
-            { isLatest: false },
-            { isLatest: true },
-            { isLatest: false },
-            { isLatest: true },
-        ]
-
+    it('retains only the selected latest row for a finite count of one', () => {
         const result = selectVisibleScreeningRows({
-            hasSubmissionLimit: true,
-            latestSubmissionIds,
+            latestSubmissionIds: new Set([
+                'member-one-latest',
+                'member-two-latest',
+            ]),
             screeningRows,
-            submissionInfos,
+            submissionLimit: 1,
         })
 
         expect(result.isRestrictedToLatest)
             .toBe(true)
         expect(result.rows)
             .toEqual([
-                screeningRows[1],
-                screeningRows[3],
+                screeningRows[2],
+                screeningRows[5],
             ])
     })
 })
diff --git a/src/apps/review/src/lib/utils/screeningRows.ts b/src/apps/review/src/lib/utils/screeningRows.ts
index c47e6a49d..74696073f 100644
--- a/src/apps/review/src/lib/utils/screeningRows.ts
+++ b/src/apps/review/src/lib/utils/screeningRows.ts
@@ -1,6 +1,4 @@
-import type { Screening, SubmissionInfo } from '../models'
-
-import { hasIsLatestFlag } from './submissionHistory'
+import type { Screening } from '../models'
 
 export interface ScreeningRowsSelection {
     isRestrictedToLatest: boolean
@@ -8,36 +6,31 @@ export interface ScreeningRowsSelection {
 }
 
 export interface SelectVisibleScreeningRowsOptions {
-    hasSubmissionLimit: boolean
     latestSubmissionIds: ReadonlySet<string>
     screeningRows: Screening[]
-    submissionInfos: Array<Pick<SubmissionInfo, 'isLatest'>>
+    submissionLimit?: number
 }
 
 /**
  * Select the Screening rows that should be displayed for a challenge.
  *
  * The Screening table uses this selection for both desktop and mobile views.
- * Limited challenges collapse submission history only when the API supplies
- * explicit `isLatest` flags. Unlimited challenges, or responses without those
- * flags, retain every Screening row. This function performs no I/O and does
- * not throw.
+ * Finite challenges retain the latest configured number of submission IDs selected
+ * independently per member and exact submission type. Unlimited challenges retain
+ * every Screening row. This function performs no I/O and does not throw.
  *
  * @param options visibility inputs for the challenge and its submissions
- * @param options.hasSubmissionLimit whether the challenge limits submissions
  * @param options.latestSubmissionIds latest submission ids calculated per member
  * @param options.screeningRows Screening rows available for display
- * @param options.submissionInfos submission metadata containing optional latest flags
+ * @param options.submissionLimit finite latest-submission count, or undefined for all
  * @returns the visible rows and whether submission history was collapsed
  */
 export function selectVisibleScreeningRows({
-    hasSubmissionLimit,
     latestSubmissionIds,
     screeningRows,
-    submissionInfos,
+    submissionLimit,
 }: SelectVisibleScreeningRowsOptions): ScreeningRowsSelection {
-    const isRestrictedToLatest = hasSubmissionLimit
-        && hasIsLatestFlag(submissionInfos)
+    const isRestrictedToLatest = submissionLimit !== undefined
 
     return {
         isRestrictedToLatest,
diff --git a/src/apps/review/src/lib/utils/submissionHistory.spec.ts b/src/apps/review/src/lib/utils/submissionHistory.spec.ts
new file mode 100644
index 000000000..6ba74773c
--- /dev/null
+++ b/src/apps/review/src/lib/utils/submissionHistory.spec.ts
@@ -0,0 +1,119 @@
+import type { SubmissionInfo } from '../models'
+
+import {
+    getSubmissionHistoryKey,
+    partitionSubmissionHistory,
+} from './submissionHistory'
+
+/**
+ * Build submission metadata for history-ranking tests.
+ *
+ * @param id - Submission identifier.
+ * @param type - Exact submission type.
+ * @param submittedDate - ISO submission timestamp.
+ * @returns A submission owned by the shared test member.
+ */
+function createSubmission(
+    id: string,
+    type: string,
+    submittedDate: string,
+): SubmissionInfo {
+    return {
+        id,
+        memberId: 'member-one',
+        submittedDate,
+        type,
+    }
+}
+
+const submissions: SubmissionInfo[] = [
+    createSubmission('contest-oldest', 'CONTEST_SUBMISSION', '2026-08-10T10:00:00Z'),
+    createSubmission('contest-middle', 'CONTEST_SUBMISSION', '2026-08-10T11:00:00Z'),
+    createSubmission('contest-newest', 'CONTEST_SUBMISSION', '2026-08-10T12:00:00Z'),
+    createSubmission('checkpoint-oldest', 'CHECKPOINT_SUBMISSION', '2026-08-09T10:00:00Z'),
+    createSubmission('checkpoint-newest', 'CHECKPOINT_SUBMISSION', '2026-08-09T11:00:00Z'),
+]
+
+describe('partitionSubmissionHistory', () => {
+    it('retains the latest two submissions independently for each exact type', () => {
+        const result = partitionSubmissionHistory(submissions, submissions, {
+            visibleSubmissionCount: 2,
+        })
+
+        expect(result.latestSubmissionIds)
+            .toEqual(new Set([
+                'contest-newest',
+                'contest-middle',
+                'checkpoint-newest',
+                'checkpoint-oldest',
+            ]))
+        expect(result.historyByMember.get(getSubmissionHistoryKey(
+            'member-one',
+            'contest-newest',
+            'CONTEST_SUBMISSION',
+        )))
+            .toEqual([submissions[0]])
+        expect(result.historyByMember.has(getSubmissionHistoryKey(
+            'member-one',
+            'checkpoint-newest',
+            'CHECKPOINT_SUBMISSION',
+        )))
+            .toBe(false)
+    })
+
+    it('defaults finite selection to the latest one per member and type', () => {
+        const result = partitionSubmissionHistory(submissions, submissions)
+
+        expect(result.latestSubmissionIds)
+            .toEqual(new Set([
+                'contest-newest',
+                'checkpoint-newest',
+            ]))
+        expect(result.historyByMember.get(getSubmissionHistoryKey(
+            'member-one',
+            'contest-newest',
+            'CONTEST_SUBMISSION',
+        )))
+            .toEqual([
+                submissions[1],
+                submissions[0],
+            ])
+        expect(result.historyByMember.get(getSubmissionHistoryKey(
+            'member-one',
+            'checkpoint-newest',
+            'CHECKPOINT_SUBMISSION',
+        )))
+            .toEqual([submissions[3]])
+    })
+
+    it('ranks complete history before retaining only eligible primary rows', () => {
+        const eligibleOlderSubmission = submissions[1]
+        const completeHistory = [
+            eligibleOlderSubmission,
+            submissions[2],
+        ]
+
+        const latestOne = partitionSubmissionHistory(
+            [eligibleOlderSubmission],
+            completeHistory,
+            { visibleSubmissionCount: 1 },
+        )
+        expect(latestOne.latestSubmissionIds)
+            .toEqual(new Set(['contest-newest']))
+        expect(latestOne.latestSubmissions)
+            .toEqual([])
+
+        const latestTwo = partitionSubmissionHistory(
+            [eligibleOlderSubmission],
+            completeHistory,
+            { visibleSubmissionCount: 2 },
+        )
+        expect(latestTwo.latestSubmissionIds)
+            .toEqual(new Set([
+                'contest-newest',
+                'contest-middle',
+            ]))
+        expect(latestTwo.latestSubmissions)
+            .toEqual([eligibleOlderSubmission])
+    })
+})
diff --git a/src/apps/review/src/lib/utils/submissionHistory.ts b/src/apps/review/src/lib/utils/submissionHistory.ts
index a82f29ce7..60ec3fbe9 100644
--- a/src/apps/review/src/lib/utils/submissionHistory.ts
+++ b/src/apps/review/src/lib/utils/submissionHistory.ts
@@ -1,26 +1,74 @@
 import { SubmissionInfo } from '../models'
 
 export interface SubmissionHistoryPartition {
-    latestSubmissions: SubmissionInfo[]
-    latestSubmissionIds: Set<string>
+    /** Older submissions grouped by member and exact normalized submission type. */
     historyByMember: Map<string, SubmissionInfo[]>
+    /** IDs of the latest configured number of submissions in every member/type group. */
+    latestSubmissionIds: Set<string>
+    /** Primary submission rows associated with the latest configured IDs. */
+    latestSubmissions: SubmissionInfo[]
+}
+
+export interface PartitionSubmissionHistoryOptions {
+    /** Positive number of submissions retained in each member/type group. Defaults to one. */
+    visibleSubmissionCount?: number
+}
+
+/**
+ * Normalize the submission type used to isolate contest and checkpoint history.
+ *
+ * @param submissionType - Submission type returned by the API.
+ * @returns A stable normalized type key, including a fallback for missing types.
+ * @throws Does not throw.
+ */
+function normalizeSubmissionHistoryType(submissionType?: string): string {
+    const normalizedType = (submissionType ?? '')
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]/g, '')
+
+    return normalizedType || '__unknown_type__'
 }
 
+/**
+ * Build the lookup key used for one member's history of an exact submission type.
+ *
+ * @param memberId - Submission owner ID, when available.
+ * @param submissionId - Submission ID used to isolate rows with no owner.
+ * @param submissionType - Exact submission type, normalized for legacy spelling variants.
+ * @returns A stable member/type history key.
+ * @throws Does not throw.
+ */
 export function getSubmissionHistoryKey(
     memberId: string | undefined,
     submissionId: string,
+    submissionType?: string,
 ): string {
-    if (memberId && memberId.length) {
-        return memberId
-    }
+    const memberKey = memberId && memberId.length
+        ? memberId
+        : `__unknown__::${submissionId}`
 
-    return `__unknown__::${submissionId}`
+    return `${memberKey}::${normalizeSubmissionHistoryType(submissionType)}`
 }
 
+/**
+ * Check whether any submission includes the API's explicit latest flag.
+ *
+ * @param submissions - Submission-like objects to inspect.
+ * @returns True when at least one object includes an `isLatest` value.
+ * @throws Does not throw.
+ */
 export function hasIsLatestFlag<T extends { isLatest?: boolean }>(submissions: T[]): boolean {
     return submissions.some(submission => submission.isLatest !== undefined)
 }
 
+/**
+ * Resolve a submission timestamp for newest-first ordering.
+ *
+ * @param submission - Submission metadata containing raw or formatted dates.
+ * @returns Milliseconds since epoch, or zero when neither date is valid.
+ * @throws Does not throw; invalid dates fall back to zero.
+ */
 function getSubmissionTimestamp(submission: SubmissionInfo): number {
     const candidates: Array<Date | undefined> = []
 
@@ -44,9 +92,40 @@ function getSubmissionTimestamp(submission: SubmissionInfo): number {
     return 0
 }
 
+/**
+ * Normalize the requested number of visible submissions per member/type group.
+ *
+ * @param visibleSubmissionCount - Raw configured visible count.
+ * @returns A positive whole-number count, defaulting to one.
+ * @throws Does not throw.
+ */
+function normalizeVisibleSubmissionCount(visibleSubmissionCount?: number): number {
+    if (!Number.isFinite(visibleSubmissionCount) || Number(visibleSubmissionCount) <= 0) {
+        return 1
+    }
+
+    return Math.max(1, Math.floor(Number(visibleSubmissionCount)))
+}
+
+/**
+ * Partition submissions into the latest configured rows and older history.
+ *
+ * Submissions are ranked independently for every member and normalized submission type. Explicit
+ * `isLatest` rows remain first for backward compatibility, followed by submission timestamp. A
+ * duplicated submission ID from the primary and complete-history inputs consumes only one slot.
+ * Only primary rows are returned for display, so ranking cannot reintroduce an ineligible history
+ * entry or promote an older eligible submission into a newer entry's configured slot.
+ *
+ * @param submissions - Primary table submissions.
+ * @param allSubmissions - Optional complete submission history used for ranking and history actions.
+ * @param options - Partition options, including the visible count per member/type group.
+ * @returns Latest submission rows and IDs plus older history grouped by member/type.
+ * @throws Does not throw; invalid visible counts default to one.
+ */
 export function partitionSubmissionHistory(
     submissions: SubmissionInfo[],
     allSubmissions?: SubmissionInfo[],
+    options: PartitionSubmissionHistoryOptions = {},
 ): SubmissionHistoryPartition {
     const byMember = new Map<string, SubmissionInfo[]>()
     const addEntry = (submission: SubmissionInfo | undefined): void => {
@@ -57,6 +136,7 @@ export function partitionSubmissionHistory(
         const memberKey = getSubmissionHistoryKey(
             submission.memberId,
             submission.id,
+            submission.type,
         )
         const list = byMember.get(memberKey)
         if (list) {
@@ -75,56 +155,46 @@ export function partitionSubmissionHistory(
     const latestSubmissions: SubmissionInfo[] = []
     const latestSubmissionIds = new Set<string>()
     const historyByMember = new Map<string, SubmissionInfo[]>()
-    const primaryIds = new Set(primarySubmissions.map(entry => entry.id))
+    const visibleSubmissionCount = normalizeVisibleSubmissionCount(
+        options.visibleSubmissionCount,
+    )
 
     byMember.forEach((entries, memberKey) => {
         const sorted = entries
             .slice()
-            .sort((a, b) => getSubmissionTimestamp(b) - getSubmissionTimestamp(a))
+            .sort((a, b) => {
+                const latestDifference = Number(Boolean(b.isLatest)) - Number(Boolean(a.isLatest))
+                if (latestDifference !== 0) {
+                    return latestDifference
+                }
 
-        const flaggedLatest = sorted.filter(entry => entry.isLatest)
-        const latestEntry = flaggedLatest.length > 0 ? flaggedLatest[0] : sorted[0]
+                return getSubmissionTimestamp(b) - getSubmissionTimestamp(a)
+            })
+        const seenSubmissionIds = new Set<string>()
+        const uniqueSorted = sorted.filter(entry => {
+            if (!entry.id || seenSubmissionIds.has(entry.id)) {
+                return false
+            }
+
+            seenSubmissionIds.add(entry.id)
+            return true
+        })
+        const visibleEntries = uniqueSorted.slice(0, visibleSubmissionCount)
+        const visibleIdsForGroup = new Set(visibleEntries.map(entry => entry.id))
 
-        if (latestEntry?.id) {
-            const latestId = latestEntry.id
+        visibleEntries.forEach(visibleEntry => {
+            const latestId = visibleEntry.id
             const matchingPrimary = primarySubmissions.filter(entry => entry.id === latestId)
-            if (matchingPrimary.length > 0) {
-                matchingPrimary.forEach(entry => {
-                    latestSubmissions.push(entry)
-                })
-            } else {
-                latestSubmissions.push(latestEntry)
-            }
+            matchingPrimary.forEach(entry => {
+                latestSubmissions.push(entry)
+            })
 
             latestSubmissionIds.add(latestId)
-        } else if (latestEntry) {
-            latestSubmissions.push(latestEntry)
-        }
+        })
 
-        const historyEntries = sorted.filter(entry => entry.id !== latestEntry?.id)
+        const historyEntries = uniqueSorted.filter(entry => !visibleIdsForGroup.has(entry.id))
         if (historyEntries.length > 0) {
-            const seenIds = new Set<string>()
-            const uniqueHistory = historyEntries.filter(entry => {
-                const key = entry.id
-                if (!key) {
-                    return false
-                }
-
-                if (primaryIds.has(key) && latestSubmissionIds.has(key)) {
-                    return false
-                }
-
-                if (seenIds.has(key)) {
-                    return false
-                }
-
-                seenIds.add(key)
-                return true
-            })
-
-            if (uniqueHistory.length > 0) {
-                historyByMember.set(memberKey, uniqueHistory)
-            }
+            historyByMember.set(memberKey, historyEntries)
         }
     })
 
diff --git a/src/apps/work/src/pages/challenges/ChallengeEditorPage/README.md b/src/apps/work/src/pages/challenges/ChallengeEditorPage/README.md
index 4f38f5fdf..f516d3be7 100644
--- a/src/apps/work/src/pages/challenges/ChallengeEditorPage/README.md
+++ b/src/apps/work/src/pages/challenges/ChallengeEditorPage/README.md
@@ -84,7 +84,7 @@ The form uses `challengeBasicInfoSchema` from `src/apps/work/src/lib/schemas/cha
 - `Submission Settings`: shown for Design `Challenge` and Design `First2Finish` types, and contains the final-deliverables, stock-art, and submission-limit compatibility fields.
 - `RegisteredMemberDownloadField`: shown in Advanced Options for every created challenge type. The radio group persists `allowAllRegistrantsToDownloadWinningSubmissions` as the exact string `true` for all challenge registrants or `false` for passing submitters only. New Development challenges default to passing submitters; other new challenges, including Design, default to all registrants. Existing challenges without the metadata retain passing-submitter-only access.
 - `FinalDeliverablesField`: design-challenge file-type editor that persists the legacy `fileTypes` metadata payload used on challenge draft pages.
-- `MaximumSubmissionsField`: submission-limit editor with `Unlimited` (the default) and `Limited` modes. Limited mode reveals a numeric count field, and both modes persist the legacy `submissionLimit` JSON metadata contract consumed by challenge and review applications. Existing limited values are restored without being overwritten, while missing or malformed metadata is normalized to unlimited after initial resource hydration so copilot restoration completes before autosave/manual-save treats the default as a user change.
+- `MaximumSubmissionsField`: submission-limit editor with `Unlimited` (the default) and `Limited` modes. Limited mode reveals a numeric count field, and both modes persist the legacy `submissionLimit` JSON metadata contract consumed by challenge and review applications. Existing limited values are restored without being overwritten, including when a draft-save response omits submission-limit metadata, while missing or malformed metadata is normalized to unlimited after initial resource hydration so copilot restoration completes before autosave/manual-save treats the default as a user change.
 - `ChallengeDescriptionField`: public markdown spec editor with a `Copy spec` action that copies
   the current Markdown in both edit and read-only view modes.
 - `ChallengePrivateDescriptionField`: optional private markdown spec editor.
diff --git a/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ChallengeEditorForm.spec.tsx b/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ChallengeEditorForm.spec.tsx
index 19a740abf..07c381caf 100644
--- a/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ChallengeEditorForm.spec.tsx
+++ b/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ChallengeEditorForm.spec.tsx
@@ -660,6 +660,12 @@ jest.mock('./MaximumSubmissionsField', () => ({
     MaximumSubmissionsField: (props: {
         deferDirty?: boolean
     }) => {
+        const reactHookForm: typeof import('react-hook-form') = jest.requireActual('react-hook-form')
+        const metadata = reactHookForm.useWatch({
+            control: reactHookForm.useFormContext().control,
+            name: 'metadata',
+        })
+
         mockMaximumSubmissionsDeferDirtyValues.push(props.deferDirty === true)
 
         return (
@@ -667,6 +673,7 @@ jest.mock('./MaximumSubmissionsField', () => ({
                 data-defer-dirty={props.deferDirty === true
                     ? 'true'
                     : 'false'}
+                data-metadata={JSON.stringify(metadata || [])}
                 data-testid='maximum-submissions-field'
             >
                 Maximum Submissions Field
@@ -4258,6 +4265,68 @@ describe('ChallengeEditorForm', () => {
             .not.toHaveBeenCalledWith(expect.stringContaining('Assign all required members'))
     })
 
+    it('keeps submission-limit metadata visible when the draft save response omits metadata', async () => {
+        const user = userEvent.setup()
+        const submissionLimitMetadata = [{
+            name: 'submissionLimit',
+            value: JSON.stringify({
+                count: '2',
+                limit: 'true',
+                unlimited: 'false',
+            }),
+        }]
+
+        mockedUseFetchChallengeTracks.mockReturnValue({
+            isLoading: false,
+            tracks: [{
+                id: 'design-track-id',
+                name: 'Design',
+                track: 'DESIGN',
+            }],
+        })
+        mockedUseFetchChallengeTypes.mockReturnValue({
+            challengeTypes: [{
+                abbreviation: 'CH',
+                id: 'design-challenge-type-id',
+                name: 'Challenge',
+            }],
+            isLoading: false,
+        })
+        mockedPatchChallenge.mockResolvedValue({
+            ...designChallengeWithDeferredScreener,
+            metadata: [],
+            status: 'DRAFT',
+        })
+
+        render(
+            <MemoryRouter initialEntries={['/projects/100578/challenges/new']}>
+                <ChallengeEditorForm
+                    challenge={{
+                        ...designChallengeWithDeferredScreener,
+                        metadata: submissionLimitMetadata,
+                        status: 'NEW',
+                    }}
+                    projectId='100578'
+                />
+            </MemoryRouter>,
+        )
+
+        expect(screen.getByTestId('maximum-submissions-field'))
+            .toHaveAttribute('data-metadata', JSON.stringify(submissionLimitMetadata))
+
+        await user.type(screen.getByLabelText('Challenge Name'), ' updated')
+        await user.click(screen.getByRole('button', { name: 'Save as Draft' }))
+
+        await waitFor(() => {
+            expect(mockedPatchChallenge)
+                .toHaveBeenCalledTimes(1)
+            expect(mockedShowSuccessToast)
+                .toHaveBeenCalled()
+            expect(screen.getByTestId('maximum-submissions-field'))
+                .toHaveAttribute('data-metadata', JSON.stringify(submissionLimitMetadata))
+        })
+    })
+
     it('reports DRAFT status when task assignee sync fails after the challenge save', async () => {
         const user = userEvent.setup()
         const onChallengeStatusChange = jest.fn()
diff --git a/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ChallengeEditorForm.tsx b/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ChallengeEditorForm.tsx
index c8ceb7d9f..68d8aff31 100644
--- a/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ChallengeEditorForm.tsx
+++ b/src/apps/work/src/pages/challenges/ChallengeEditorPage/components/ChallengeEditorForm.tsx
@@ -85,7 +85,11 @@ import {
     transformChallengeToFormData,
     transformFormDataToChallenge,
 } from '../../../../lib/utils'
-import { booleanToMetadata } from '../../../../lib/utils/metadata.utils'
+import {
+    booleanToMetadata,
+    getMetadataValue,
+    setMetadataValue,
+} from '../../../../lib/utils/metadata.utils'
 import { isScreenerAssignmentOptional } from '../../../../lib/utils/reviewer.utils'
 import {
     getProjectBillingAccountChallengeErrorMessage,
@@ -3327,6 +3331,25 @@ export const ChallengeEditorForm: FC<ChallengeEditorFormProps> = (
                         formDataWithProjectBilling.phases,
                         persistedFormData.phases,
                     )
+                const savedMetadata = Array.isArray(savedChallengeSnapshot.metadata)
+                    ? persistedFormData.metadata
+                    : formDataWithProjectBilling.metadata
+                const submittedSubmissionLimit = getMetadataValue(
+                    formDataWithProjectBilling.metadata,
+                    'submissionLimit',
+                )
+                const savedSubmissionLimit = getMetadataValue(
+                    savedMetadata,
+                    'submissionLimit',
+                )
+                const postSaveMetadata = submittedSubmissionLimit === undefined
+                    || savedSubmissionLimit !== undefined
+                    ? savedMetadata
+                    : setMetadataValue(
+                        savedMetadata,
+                        'submissionLimit',
+                        submittedSubmissionLimit,
+                    )
 
                 const nextValues = applySingleAssignmentFieldValues(
                     await hydratePersistedSavedFormData(
@@ -3336,6 +3359,7 @@ export const ChallengeEditorForm: FC<ChallengeEditorFormProps> = (
                             attachments: Array.isArray(persistedFormData.attachments)
                                 ? persistedFormData.attachments
                                 : formDataWithProjectBilling.attachments,
+                            metadata: postSaveMetadata,
                         },
                     ),
                     formDataWithProjectBilling,

From 9eafb1f316c29e0c68bfac8cdf52a474f814f3e5 Mon Sep 17 00:00:00 2001
From: Justin Gasper <jmgasper@gmail.com>
Date: Wed, 12 Aug 2026 20:59:04 +1000
Subject: [PATCH 07/13] PM-5857: Label support team replies

What was broken
Support staff and ticket raiser replies displayed only their handles, making their roles difficult to distinguish.

Root cause
The ticket conversation rendered reply handles without using the existing author and ticket-owner IDs to identify support-authored responses.

What was changed
Append (Support Team) to replies authored by someone other than the ticket owner. Ticket-owner replies remain unchanged, including when the owner also holds the Support Team role.

Any added/updated tests
Added TicketDetailPage coverage that verifies the suffix appears for support replies and not for ticket-owner replies.
---
 .../ticket-details/TicketDetailPage.spec.tsx  | 41 +++++++++++++++++++
 .../pages/ticket-details/TicketDetailPage.tsx |  3 +-
 2 files changed, 43 insertions(+), 1 deletion(-)

diff --git a/src/apps/support/src/pages/ticket-details/TicketDetailPage.spec.tsx b/src/apps/support/src/pages/ticket-details/TicketDetailPage.spec.tsx
index 66b321d20..c512433e8 100644
--- a/src/apps/support/src/pages/ticket-details/TicketDetailPage.spec.tsx
+++ b/src/apps/support/src/pages/ticket-details/TicketDetailPage.spec.tsx
@@ -242,6 +242,47 @@ describe('TicketDetailPage reply access', () => {
             .toBeUndefined()
     })
 
+    it('identifies support team replies without labelling the ticket owner', () => {
+        mockUseSWR.mockReturnValue({
+            data: {
+                ...closedTicket,
+                responseCount: 2,
+                responses: [{
+                    createdAt: '2026-08-07T01:30:00.000Z',
+                    id: 'response-owner',
+                    markdown: 'Member follow-up.',
+                    readBy: [],
+                    userHandle: 'ticket-owner',
+                    userId: '12345',
+                }, {
+                    createdAt: '2026-08-07T01:45:00.000Z',
+                    id: 'response-support',
+                    markdown: 'Support follow-up.',
+                    readBy: [],
+                    userHandle: 'support-agent',
+                    userId: '67890',
+                }],
+            },
+            error: undefined,
+            isValidating: false,
+            mutate: mockMutate,
+        })
+
+        render(<TicketDetailPage />)
+
+        const ownerReply = screen.getByText('Member follow-up.')
+            .closest('article')
+        const supportReply = screen.getByText('Support follow-up.')
+            .closest('article')
+
+        expect(ownerReply?.textContent)
+            .toContain('ticket-owner')
+        expect(ownerReply?.textContent)
+            .not.toContain('(Support Team)')
+        expect(supportReply?.textContent)
+            .toContain('support-agent (Support Team)')
+    })
+
     it('requires non-owner support staff to assign an open ticket before replying', () => {
         mockProfile = {
             roles: ['Topcoder Support Team'],
diff --git a/src/apps/support/src/pages/ticket-details/TicketDetailPage.tsx b/src/apps/support/src/pages/ticket-details/TicketDetailPage.tsx
index 4df066db3..fcf8c7aa7 100644
--- a/src/apps/support/src/pages/ticket-details/TicketDetailPage.tsx
+++ b/src/apps/support/src/pages/ticket-details/TicketDetailPage.tsx
@@ -43,7 +43,7 @@ import {
 import styles from './TicketDetailPage.module.scss'
 
 /**
- * Renders the original request followed by ascending replies and authorized actions.
+ * Renders the original request followed by ascending, role-labelled replies and authorized actions.
  *
  * @returns support ticket detail page.
  * @throws Does not throw; request failures are shown with recovery actions.
@@ -297,6 +297,7 @@ export const TicketDetailPage: FC = () => {
                                             color={response.userHandleColor}
                                             handle={response.userHandle}
                                         />
+                                        {response.userId !== data.memberUserId && ' (Support Team)'}
                                     </span>
                                     <time dateTime={response.createdAt}>{formatSupportDate(response.createdAt)}</time>
                                 </header>

From e6ad41979fc25fd47b422479fd2fe264cb49a534 Mon Sep 17 00:00:00 2001
From: Justin Gasper <jmgasper@gmail.com>
Date: Wed, 12 Aug 2026 21:31:49 +1000
Subject: [PATCH 08/13] PM-5853: Rename active challenge label

What was broken

The Open support request modal labeled its challenge picker "Challenge (if applicable)" even though only active challenges are available.

Root cause

The picker label did not reflect the active-status filter already applied by the challenge service.

What was changed

Renamed the picker label to "Active Challenge (if applicable)".

Any added/updated tests

Updated the existing modal tests to query and verify the new accessible label.
---
 .../OpenSupportRequestModal.spec.tsx                        | 6 +++---
 .../OpenSupportRequestModal/OpenSupportRequestModal.tsx     | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/apps/support/src/lib/components/OpenSupportRequestModal/OpenSupportRequestModal.spec.tsx b/src/apps/support/src/lib/components/OpenSupportRequestModal/OpenSupportRequestModal.spec.tsx
index cf72bf26a..1829612bf 100644
--- a/src/apps/support/src/lib/components/OpenSupportRequestModal/OpenSupportRequestModal.spec.tsx
+++ b/src/apps/support/src/lib/components/OpenSupportRequestModal/OpenSupportRequestModal.spec.tsx
@@ -144,7 +144,7 @@ describe('OpenSupportRequestModal', () => {
         expect(screen.getByRole('dialog')
             .getAttribute('data-size'))
             .toBe('body')
-        const challengeSelect = screen.getByLabelText('Challenge (if applicable)') as HTMLSelectElement
+        const challengeSelect = screen.getByLabelText('Active Challenge (if applicable)') as HTMLSelectElement
         expect(challengeSelect.options[0].text)
             .toBe('Select challenge')
         expect(mockUseSWR.mock.calls[0][0])
@@ -155,7 +155,7 @@ describe('OpenSupportRequestModal', () => {
         expect(mockedGetActiveChallenges)
             .toHaveBeenCalledWith('12345')
 
-        fireEvent.change(screen.getByLabelText('Challenge (if applicable)'), {
+        fireEvent.change(screen.getByLabelText('Active Challenge (if applicable)'), {
             target: { value: 'challenge-2' },
         })
         fireEvent.change(screen.getByLabelText('Description'), {
@@ -209,7 +209,7 @@ describe('OpenSupportRequestModal', () => {
             />,
         )
 
-        fireEvent.change(screen.getByLabelText('Challenge (if applicable)'), {
+        fireEvent.change(screen.getByLabelText('Active Challenge (if applicable)'), {
             target: { value: 'challenge-2' },
         })
         mockUseSWR.mockReturnValue({
diff --git a/src/apps/support/src/lib/components/OpenSupportRequestModal/OpenSupportRequestModal.tsx b/src/apps/support/src/lib/components/OpenSupportRequestModal/OpenSupportRequestModal.tsx
index d3ca825f9..a24197bc3 100644
--- a/src/apps/support/src/lib/components/OpenSupportRequestModal/OpenSupportRequestModal.tsx
+++ b/src/apps/support/src/lib/components/OpenSupportRequestModal/OpenSupportRequestModal.tsx
@@ -192,7 +192,7 @@ export const OpenSupportRequestModal: FC<OpenSupportRequestModalProps> = props =
         >
             <div className={styles.form}>
                 <div className={styles.challengeField}>
-                    <label htmlFor='support-challenge-id'>Challenge (if applicable)</label>
+                    <label htmlFor='support-challenge-id'>Active Challenge (if applicable)</label>
                     <Select<ChallengeOption, false>
                         aria-describedby={challengeError ? 'support-challenge-error' : undefined}
                         className={styles.challengeSelect}

From d2ffa7a775f5c30d8608f7d71509607735846958 Mon Sep 17 00:00:00 2001
From: Justin Gasper <jmgasper@gmail.com>
Date: Wed, 12 Aug 2026 21:50:50 +1000
Subject: [PATCH 09/13] PM-5852: Open support description links in new tabs

What was broken
Links rendered from a support ticket Description navigated the current Support tab instead of opening a new tab.

Root cause
The shared Support Markdown renderer used ReactMarkdown's default anchor output, which does not set a new-tab target.

What was changed
Added a scoped Markdown anchor renderer that preserves the link destination while applying target="_blank" and rel="noopener noreferrer". Updated the renderer documentation to describe the behavior.

Any added/updated tests
Added regression coverage for the bare GFM challenge URL shown in the ticket recording, including href, target, and rel assertions. All 9 Support test suites, lint, and the production build pass. The repository-wide suite still has unrelated failures reproduced on clean origin/dev.
---
 .../MarkdownContent/MarkdownContent.spec.tsx  | 26 ++++++++++++++++++
 .../MarkdownContent/MarkdownContent.tsx       | 27 ++++++++++++++++---
 2 files changed, 50 insertions(+), 3 deletions(-)

diff --git a/src/apps/support/src/lib/components/MarkdownContent/MarkdownContent.spec.tsx b/src/apps/support/src/lib/components/MarkdownContent/MarkdownContent.spec.tsx
index f47188cf3..79f398813 100644
--- a/src/apps/support/src/lib/components/MarkdownContent/MarkdownContent.spec.tsx
+++ b/src/apps/support/src/lib/components/MarkdownContent/MarkdownContent.spec.tsx
@@ -1,5 +1,6 @@
 /* eslint-disable import/no-extraneous-dependencies, ordered-imports/ordered-imports */
 import '@testing-library/jest-dom'
+import type { ElementType } from 'react'
 import { readFileSync } from 'fs'
 import { render, screen } from '@testing-library/react'
 import remarkBreaks from 'remark-breaks'
@@ -9,6 +10,9 @@ import { MarkdownContent } from './MarkdownContent'
 
 interface MarkdownRendererProps {
     children: string
+    components: {
+        a: ElementType
+    }
     remarkPlugins: unknown[]
     skipHtml: boolean
 }
@@ -65,6 +69,28 @@ describe('MarkdownContent', () => {
             }))
     })
 
+    it('opens GFM links in a safe new tab', () => {
+        const markdown = 'https://www.topcoder-dev.com/challenges'
+
+        render(<MarkdownContent markdown={markdown} />)
+        const markdownProps = mockReactMarkdown.mock.calls[0][0] as MarkdownRendererProps
+        const MarkdownLink = markdownProps.components.a
+
+        render(
+            <MarkdownLink href={markdown}>
+                {markdown}
+            </MarkdownLink>,
+        )
+        const link = screen.getByRole('link', { name: markdown })
+
+        expect(link)
+            .toHaveAttribute('href', markdown)
+        expect(link)
+            .toHaveAttribute('target', '_blank')
+        expect(link)
+            .toHaveAttribute('rel', 'noopener noreferrer')
+    })
+
     it('keeps Markdown formatting visible after the platform style reset', () => {
         expect(markdownStyles)
             .toMatch(/a,[\s\S]*a:hover \{[\s\S]*color: \$link-blue-dark;[\s\S]*text-decoration: underline;/)
diff --git a/src/apps/support/src/lib/components/MarkdownContent/MarkdownContent.tsx b/src/apps/support/src/lib/components/MarkdownContent/MarkdownContent.tsx
index 8a0d1fb31..ce0c367d7 100644
--- a/src/apps/support/src/lib/components/MarkdownContent/MarkdownContent.tsx
+++ b/src/apps/support/src/lib/components/MarkdownContent/MarkdownContent.tsx
@@ -1,6 +1,6 @@
 /** Safe Markdown renderer for user-authored support content. */
-import { FC } from 'react'
-import ReactMarkdown from 'react-markdown'
+import type { FC } from 'react'
+import ReactMarkdown, { type Components } from 'react-markdown'
 import remarkBreaks from 'remark-breaks'
 import remarkGfm from 'remark-gfm'
 
@@ -10,8 +10,28 @@ export interface MarkdownContentProps {
     markdown: string
 }
 
+const markdownComponents: Components = {
+    /**
+     * Renders a Markdown link in a new tab without exposing the opener page.
+     *
+     * @param props anchor attributes and AST metadata produced by ReactMarkdown.
+     * @returns a safely targeted anchor used for links in support conversations.
+     * @throws Does not throw.
+     */
+    a: props => (
+        <a
+            href={props.href}
+            rel='noopener noreferrer'
+            target='_blank'
+            title={props.title}
+        >
+            {props.children}
+        </a>
+    ),
+}
+
 /**
- * Renders GFM and line breaks while dropping raw HTML.
+ * Renders GFM and line breaks with links opening in new tabs while dropping raw HTML.
  *
  * @param props untrusted Markdown source.
  * @returns safely rendered Markdown.
@@ -20,6 +40,7 @@ export interface MarkdownContentProps {
 export const MarkdownContent: FC<MarkdownContentProps> = props => (
     <div className={styles.markdown}>
         <ReactMarkdown
+            components={markdownComponents}
             remarkPlugins={[remarkGfm, remarkBreaks]}
             skipHtml
         >

From 12a043e02bb9da03b36e7660e6aae38409145df7 Mon Sep 17 00:00:00 2001
From: himaniraghav3 <himaniraghav0311@gmail.com>
Date: Thu, 13 Aug 2026 12:49:25 +0530
Subject: [PATCH 10/13] PM-5381 Add Member not found page for non existing
 handles

---
 .../MemberNotFound/MemberNotFound.module.scss | 31 ++++++++++++
 .../MemberNotFound/MemberNotFound.tsx         | 48 +++++++++++++++++++
 .../src/components/MemberNotFound/index.ts    |  1 +
 src/apps/profiles/src/components/index.ts     |  1 +
 .../src/member-badges/MemberBadgesPage.tsx    | 23 +++++++--
 .../src/member-profile/MemberProfilePage.tsx  | 16 +++++--
 6 files changed, 113 insertions(+), 7 deletions(-)
 create mode 100644 src/apps/profiles/src/components/MemberNotFound/MemberNotFound.module.scss
 create mode 100644 src/apps/profiles/src/components/MemberNotFound/MemberNotFound.tsx
 create mode 100644 src/apps/profiles/src/components/MemberNotFound/index.ts

diff --git a/src/apps/profiles/src/components/MemberNotFound/MemberNotFound.module.scss b/src/apps/profiles/src/components/MemberNotFound/MemberNotFound.module.scss
new file mode 100644
index 000000000..6fab0c29a
--- /dev/null
+++ b/src/apps/profiles/src/components/MemberNotFound/MemberNotFound.module.scss
@@ -0,0 +1,31 @@
+@import "@libs/ui/styles/includes";
+
+.container {
+    min-height: 60vh;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+
+.content {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    text-align: center;
+    gap: $sp-6;
+    padding: $sp-15 $sp-8;
+    color: $black-100;
+
+    svg {
+        color: $black-60;
+    }
+}
+
+.title {
+    @include font-barlow;
+    font-weight: 600;
+    font-size: 28px;
+    line-height: 34px;
+    margin: 0;
+}
diff --git a/src/apps/profiles/src/components/MemberNotFound/MemberNotFound.tsx b/src/apps/profiles/src/components/MemberNotFound/MemberNotFound.tsx
new file mode 100644
index 000000000..24130076f
--- /dev/null
+++ b/src/apps/profiles/src/components/MemberNotFound/MemberNotFound.tsx
@@ -0,0 +1,48 @@
+import { FC, useCallback } from 'react'
+import { useNavigate } from 'react-router-dom'
+
+import { Button, ContentLayout, IconOutline, IconSolid, PageTitle } from '~/libs/ui'
+
+import styles from './MemberNotFound.module.scss'
+
+interface MemberNotFoundProps {
+    memberHandle?: string
+}
+
+const MemberNotFound: FC<MemberNotFoundProps> = (props: MemberNotFoundProps) => {
+    const navigate = useNavigate()
+
+    const handleBack = useCallback(() => {
+        navigate(-1)
+    }, [navigate])
+
+    return (
+        <ContentLayout outerClass={styles.container}>
+            <PageTitle>Profile Not Found | Topcoder</PageTitle>
+
+            <div className={styles.content} role='alert'>
+                <IconOutline.ExclamationCircleIcon className='icon-xxxl' />
+                <h2 className={styles.title}>We were unable to locate that profile</h2>
+                {props.memberHandle && (
+                    <p className='body-main'>
+                        No member was found with the handle
+                        {' '}
+                        <strong>{props.memberHandle}</strong>
+                        .
+                    </p>
+                )}
+                <Button
+                    link
+                    size='lg'
+                    iconToLeft
+                    icon={IconSolid.ArrowLeftIcon}
+                    onClick={handleBack}
+                >
+                    Go back
+                </Button>
+            </div>
+        </ContentLayout>
+    )
+}
+
+export default MemberNotFound
diff --git a/src/apps/profiles/src/components/MemberNotFound/index.ts b/src/apps/profiles/src/components/MemberNotFound/index.ts
new file mode 100644
index 000000000..e48b4584b
--- /dev/null
+++ b/src/apps/profiles/src/components/MemberNotFound/index.ts
@@ -0,0 +1 @@
+export { default as MemberNotFound } from './MemberNotFound'
diff --git a/src/apps/profiles/src/components/index.ts b/src/apps/profiles/src/components/index.ts
index 8bb7e5e34..bed93b6c6 100644
--- a/src/apps/profiles/src/components/index.ts
+++ b/src/apps/profiles/src/components/index.ts
@@ -4,3 +4,4 @@ export * from './tc-achievements/SRMView/ChallengesGrid'
 export * from './EditMemberPropertyBtn'
 export * from './AddButton'
 export * from './EmptySection'
+export * from './MemberNotFound'
diff --git a/src/apps/profiles/src/member-badges/MemberBadgesPage.tsx b/src/apps/profiles/src/member-badges/MemberBadgesPage.tsx
index ae271f591..d55e3bac3 100644
--- a/src/apps/profiles/src/member-badges/MemberBadgesPage.tsx
+++ b/src/apps/profiles/src/member-badges/MemberBadgesPage.tsx
@@ -1,11 +1,12 @@
 import { Dispatch, FC, SetStateAction, useCallback, useEffect, useState } from 'react'
 import { Params, useNavigate, useParams } from 'react-router-dom'
+import { AxiosError } from 'axios'
 import { bind } from 'lodash'
 
 import { profileGetPublicAsync, useMemberBadges, UserBadge, UserBadgesResponse, UserProfile } from '~/libs/core'
 import { Button, ContentLayout, IconSolid, LoadingSpinner } from '~/libs/ui'
 
-import { MemberBadgeModal } from '../components'
+import { MemberBadgeModal, MemberNotFound } from '../components'
 
 import styles from './MemberBadgesPage.module.scss'
 
@@ -19,6 +20,7 @@ const MemberBadgesPage: FC<{}> = () => {
     ] = useState()
 
     const [profileReady, setProfileReady]: [boolean, Dispatch<SetStateAction<boolean>>] = useState<boolean>(false)
+    const [notFound, setNotFound]: [boolean, Dispatch<SetStateAction<boolean>>] = useState<boolean>(false)
 
     const memberBadges: UserBadgesResponse | undefined = useMemberBadges(profile?.userId as number, { limit: 100 })
 
@@ -39,12 +41,21 @@ const MemberBadgesPage: FC<{}> = () => {
 
     useEffect(() => {
         if (routeParams.memberHandle) {
+            setProfileReady(false)
+            setNotFound(false)
+            setProfile(undefined)
+
             profileGetPublicAsync(routeParams.memberHandle)
                 .then(userProfile => {
                     setProfile(userProfile)
                     setProfileReady(true)
                 })
-            // TODO: NOT FOUND PAGE redirect/dispaly via catch
+                .catch((e: AxiosError) => {
+                    if (e.code === AxiosError.ERR_BAD_REQUEST && e.response?.status === 404) {
+                        setNotFound(true)
+                        setProfileReady(true)
+                    }
+                })
         }
     }, [routeParams.memberHandle])
 
@@ -54,9 +65,13 @@ const MemberBadgesPage: FC<{}> = () => {
 
     return (
         <>
-            <LoadingSpinner hide={profileReady && !!memberBadges} />
+            <LoadingSpinner hide={profileReady && (notFound || !!memberBadges)} />
+
+            {profileReady && notFound && (
+                <MemberNotFound memberHandle={routeParams.memberHandle} />
+            )}
 
-            {profileReady && profile && !!memberBadges && (
+            {profileReady && profile && !notFound && !!memberBadges && (
                 <ContentLayout
                     outerClass={styles.container}
                 >
diff --git a/src/apps/profiles/src/member-profile/MemberProfilePage.tsx b/src/apps/profiles/src/member-profile/MemberProfilePage.tsx
index d5a85cf72..7bdead5cb 100644
--- a/src/apps/profiles/src/member-profile/MemberProfilePage.tsx
+++ b/src/apps/profiles/src/member-profile/MemberProfilePage.tsx
@@ -5,7 +5,7 @@ import { AxiosError } from 'axios'
 import { profileContext, ProfileContextData, profileGetPublicAsync, UserProfile } from '~/libs/core'
 import { LoadingSpinner } from '~/libs/ui'
 
-import { rootRoute } from '../profiles.routes'
+import { MemberNotFound } from '../components'
 import { notifyUniNavi } from '../lib'
 
 import { ProfilePageLayout } from './page-layout'
@@ -21,6 +21,7 @@ const MemberProfilePage: FC<{}> = () => {
     ] = useState()
 
     const [profileReady, setProfileReady]: [boolean, Dispatch<SetStateAction<boolean>>] = useState<boolean>(false)
+    const [notFound, setNotFound]: [boolean, Dispatch<SetStateAction<boolean>>] = useState<boolean>(false)
     const { isTalentSearch }: MemberProfileContextValue = useMemberProfileContext()
 
     const { profile: authProfile }: ProfileContextData = useContext(profileContext)
@@ -31,6 +32,10 @@ const MemberProfilePage: FC<{}> = () => {
 
     useEffect(() => {
         if (routeParams.memberHandle) {
+            setProfileReady(false)
+            setNotFound(false)
+            setProfile(undefined)
+
             profileGetPublicAsync(routeParams.memberHandle)
                 .then(userProfile => {
                     setProfile({ ...userProfile } as UserProfile)
@@ -38,7 +43,8 @@ const MemberProfilePage: FC<{}> = () => {
                 })
                 .catch((e: AxiosError) => {
                     if (e.code === AxiosError.ERR_BAD_REQUEST && e.response?.status === 404) {
-                        navigate(rootRoute)
+                        setNotFound(true)
+                        setProfileReady(true)
                     }
                 })
         }
@@ -58,7 +64,11 @@ const MemberProfilePage: FC<{}> = () => {
         <>
             <LoadingSpinner hide={profileReady} />
 
-            {profileReady && profile && (
+            {profileReady && notFound && (
+                <MemberNotFound memberHandle={routeParams.memberHandle} />
+            )}
+
+            {profileReady && profile && !notFound && (
                 <ProfilePageLayout
                     handleBackBtn={handleBackBtn}
                     isTalentSearch={isTalentSearch}

From ebb2b98d037623d8e4133e05408c3b0a69064b71 Mon Sep 17 00:00:00 2001
From: himaniraghav3 <himaniraghav0311@gmail.com>
Date: Thu, 13 Aug 2026 16:03:21 +0530
Subject: [PATCH 11/13] PM-5879 Fix rating charts label

---
 .../MemberRatingInfoModal.spec.tsx            | 19 +++++++++++++
 .../MemberRatingInfoModal.tsx                 | 28 ++++++++++++++++++-
 2 files changed, 46 insertions(+), 1 deletion(-)

diff --git a/src/apps/profiles/src/member-profile/about-me/MemberRatingCard/MemberRatingInfoModal/MemberRatingInfoModal.spec.tsx b/src/apps/profiles/src/member-profile/about-me/MemberRatingCard/MemberRatingInfoModal/MemberRatingInfoModal.spec.tsx
index 549073927..bdb7fee56 100644
--- a/src/apps/profiles/src/member-profile/about-me/MemberRatingCard/MemberRatingInfoModal/MemberRatingInfoModal.spec.tsx
+++ b/src/apps/profiles/src/member-profile/about-me/MemberRatingCard/MemberRatingInfoModal/MemberRatingInfoModal.spec.tsx
@@ -212,4 +212,23 @@ describe('MemberRatingInfoModal', () => {
         expect(parseFloat(marker.style.left))
             .toBeCloseTo((3.5 / 6) * 100)
     })
+
+    it('hides the 2200+ axis label when the distribution has no elite buckets', () => {
+        render(
+            <MemberRatingInfoModal
+                audienceLabel='developers'
+                onClose={jest.fn()}
+                percentile={15}
+                profile={baseProfile}
+                rating={1646}
+                ratingDistribution={ratingDistribution}
+            />,
+        )
+
+        expect(screen.getByText('1500'))
+            .toBeInTheDocument()
+        expect(screen.queryByText('2200+'))
+            .not
+            .toBeInTheDocument()
+    })
 })
diff --git a/src/apps/profiles/src/member-profile/about-me/MemberRatingCard/MemberRatingInfoModal/MemberRatingInfoModal.tsx b/src/apps/profiles/src/member-profile/about-me/MemberRatingCard/MemberRatingInfoModal/MemberRatingInfoModal.tsx
index a2d34df9b..d3a4ca25e 100644
--- a/src/apps/profiles/src/member-profile/about-me/MemberRatingCard/MemberRatingInfoModal/MemberRatingInfoModal.tsx
+++ b/src/apps/profiles/src/member-profile/about-me/MemberRatingCard/MemberRatingInfoModal/MemberRatingInfoModal.tsx
@@ -292,6 +292,29 @@ const getAxisLabelPosition = (
     return 100
 }
 
+/**
+ * Returns axis labels that fall within the visible distribution ranges.
+ *
+ * Hides labels such as `2200+` when the trimmed histogram has no elite buckets,
+ * which otherwise stack on top of the final label (e.g. `1500`).
+ *
+ * @param {RatingDistributionRange[]} ranges - Visible rating distribution ranges.
+ * @returns {Array<{ label: string, value: number }>} Axis labels to render.
+ */
+const getVisibleAxisLabels = (
+    ranges: RatingDistributionRange[],
+): Array<{ label: string, value: number }> => {
+    if (ranges.length === 0) {
+        return chartAxisLabels
+    }
+
+    const chartEnd = ranges[ranges.length - 1].end
+
+    return chartAxisLabels.filter((axisLabel: { label: string, value: number }) => (
+        axisLabel.value <= chartEnd
+    ))
+}
+
 /**
  * Calculates a bar height for a histogram count.
  *
@@ -359,6 +382,9 @@ const MemberRatingInfoModal: FC<MemberRatingInfoModalProps> = (props: MemberRati
     const markerPosition: number = props.rating !== undefined
         ? getMarkerPosition(props.rating, distributionRanges)
         : 0
+    const visibleAxisLabels: Array<{ label: string, value: number }> = useMemo(() => (
+        getVisibleAxisLabels(distributionRanges)
+    ), [distributionRanges])
     const shouldStackMarkerRating: boolean = props.rating !== undefined && (
         markerPosition >= stackedMarkerPositionThreshold
         || props.rating >= stackedMarkerRatingThreshold
@@ -476,7 +502,7 @@ const MemberRatingInfoModal: FC<MemberRatingInfoModalProps> = (props: MemberRati
                             )}
 
                             <div className={styles.axisLabels}>
-                                {chartAxisLabels.map((axisLabel: { label: string, value: number }) => (
+                                {visibleAxisLabels.map((axisLabel: { label: string, value: number }) => (
                                     <span
                                         key={axisLabel.label}
                                         style={{

From d0078fddc50910b6cedaa7ed5592c50b108e1855 Mon Sep 17 00:00:00 2001
From: himaniraghav3 <himaniraghav0311@gmail.com>
Date: Thu, 13 Aug 2026 17:24:44 +0530
Subject: [PATCH 12/13] PM-5819 Fix engagement details styling

---
 .../EngagementDetailsPage.module.scss         | 112 +++++++++++++++++-
 1 file changed, 109 insertions(+), 3 deletions(-)

diff --git a/src/apps/work/src/pages/engagements/EngagementDetailsPage/EngagementDetailsPage.module.scss b/src/apps/work/src/pages/engagements/EngagementDetailsPage/EngagementDetailsPage.module.scss
index ea4ff84e3..4da57dc47 100644
--- a/src/apps/work/src/pages/engagements/EngagementDetailsPage/EngagementDetailsPage.module.scss
+++ b/src/apps/work/src/pages/engagements/EngagementDetailsPage/EngagementDetailsPage.module.scss
@@ -81,13 +81,119 @@
     font-size: 14px;
     line-height: 1.5;
 
-    :global(p) {
-        margin: 0 0 12px;
+    // Element tags are not hashed by CSS Modules; avoid nested :global(...)
+    // which Sass can leave as a literal pseudo that never matches.
+    p {
+        margin: 0 0 15px;
     }
 
-    :global(p:last-child) {
+
+
+    ul,
+    ol {
+        margin: 0 0 20px;
+        padding-left: 24px;
+        list-style-position: outside;
+    }
+
+    ul {
+        list-style-type: disc;
+    }
+
+    ol {
+        list-style-type: decimal;
+    }
+
+    li {
+        margin-bottom: 6px;
+    }
+
+    li:last-child {
         margin-bottom: 0;
     }
+
+    h1,
+    h2,
+    h3,
+    h4,
+    h5,
+    h6 {
+        font-family: inherit;
+        text-transform: none;
+        letter-spacing: normal;
+        color: #2a2a2a;
+    }
+
+    h1 {
+        margin: 28px 0 14px;
+        font-size: 1.4rem;
+        font-weight: 700;
+        line-height: 1.3;
+    }
+
+    h2 {
+        margin: 24px 0 14px;
+        font-size: 1.25rem;
+        font-weight: 700;
+        line-height: 1.3;
+    }
+
+    h3 {
+        margin: 22px 0 12px;
+        font-size: 1.1rem;
+        font-weight: 600;
+        line-height: 1.35;
+    }
+
+    h4,
+    h5,
+    h6 {
+        margin: 20px 0 12px;
+        font-size: 1rem;
+        font-weight: 600;
+        line-height: 1.4;
+    }
+
+    strong {
+        color: #2a2a2a;
+    }
+
+    a {
+        color: $link-blue-dark;
+        text-decoration: underline;
+    }
+
+    blockquote {
+        margin: 0 0 20px;
+        padding-left: 12px;
+        border-left: 3px solid #d8dee8;
+        color: #5b5b5b;
+    }
+
+    code {
+        font-family: 'SFMono-Regular', Consolas, 'Liberation Mono', Menlo, monospace;
+        font-size: 0.9em;
+        background: #f5f7fa;
+        border: 1px solid #d8dee8;
+        border-radius: 6px;
+        padding: 1px 4px;
+    }
+
+    pre {
+        margin: 0 0 20px;
+        background: #f5f7fa;
+        border: 1px solid #d8dee8;
+        border-radius: 12px;
+        padding: 12px;
+        overflow-x: auto;
+    }
+
+    pre code {
+        background: transparent;
+        border: none;
+        padding: 0;
+        font-size: 0.9rem;
+    }
 }
 
 .skills {

From 45a64961e8a1845018f27af7913c5e1732a2e5f2 Mon Sep 17 00:00:00 2001
From: himaniraghav3 <himaniraghav0311@gmail.com>
Date: Thu, 13 Aug 2026 21:08:12 +0530
Subject: [PATCH 13/13] PM-5820 Show N/A daysLeftInEngagement for terminated
 assignments

---
 .../work/src/lib/utils/assignment-dates.utils.spec.ts  | 10 +++++++++-
 src/apps/work/src/lib/utils/assignment-dates.utils.ts  |  4 ++--
 .../EngagementPaymentPage/EngagementPaymentPage.tsx    |  6 +++++-
 3 files changed, 16 insertions(+), 4 deletions(-)

diff --git a/src/apps/work/src/lib/utils/assignment-dates.utils.spec.ts b/src/apps/work/src/lib/utils/assignment-dates.utils.spec.ts
index 5d220b6a4..d8b1d6399 100644
--- a/src/apps/work/src/lib/utils/assignment-dates.utils.spec.ts
+++ b/src/apps/work/src/lib/utils/assignment-dates.utils.spec.ts
@@ -57,7 +57,7 @@ describe('assignment-dates.utils', () => {
                 .toBe('-')
         })
 
-        it('returns N/A for cancelled or closed engagements', () => {
+        it('returns N/A for cancelled or closed engagements, and terminated assignments', () => {
             expect(formatAssignmentDaysLeftInEngagement(
                 '2026-01-01T12:00:00.000Z',
                 1,
@@ -74,6 +74,14 @@ describe('assignment-dates.utils', () => {
             ))
                 .toBe('N/A')
 
+            expect(formatAssignmentDaysLeftInEngagement(
+                '2026-01-01T12:00:00.000Z',
+                1,
+                'TERMINATED',
+                new Date('2026-01-16T12:00:00.000Z'),
+            ))
+                .toBe('N/A')
+
             expect(formatAssignmentDaysLeftInEngagement(
                 '2026-01-01T12:00:00.000Z',
                 1,
diff --git a/src/apps/work/src/lib/utils/assignment-dates.utils.ts b/src/apps/work/src/lib/utils/assignment-dates.utils.ts
index b4131d744..1af058d81 100644
--- a/src/apps/work/src/lib/utils/assignment-dates.utils.ts
+++ b/src/apps/work/src/lib/utils/assignment-dates.utils.ts
@@ -146,11 +146,11 @@ export function getAssignmentDaysLeftInEngagement(
 /**
  * Formats remaining engagement days for Assignments list display.
  *
- * Cancelled or closed engagements show `N/A`.
+ * Cancelled or closed engagements, and terminated assignments, show `N/A`.
  *
  * @param startDate billing start date.
  * @param durationMonths assignment duration in months.
- * @param engagementStatus optional engagement status.
+ * @param engagementStatus optional engagement or assignment status.
  * @param now optional "today" override for tests.
  * @returns display string such as `16 days`, `N/A`, or `-` when unavailable.
  */
diff --git a/src/apps/work/src/pages/engagements/EngagementPaymentPage/EngagementPaymentPage.tsx b/src/apps/work/src/pages/engagements/EngagementPaymentPage/EngagementPaymentPage.tsx
index 00310dd07..fc600120c 100644
--- a/src/apps/work/src/pages/engagements/EngagementPaymentPage/EngagementPaymentPage.tsx
+++ b/src/apps/work/src/pages/engagements/EngagementPaymentPage/EngagementPaymentPage.tsx
@@ -1125,7 +1125,11 @@ export const EngagementPaymentPage: FC = () => {
                                                     {formatAssignmentDaysLeftInEngagement(
                                                         assignment.startDate,
                                                         assignment.durationMonths,
-                                                        engagementResult.engagement?.status,
+                                                        String(assignment.status || '')
+                                                            .trim()
+                                                            .toUpperCase() === 'TERMINATED'
+                                                            ? assignment.status
+                                                            : engagementResult.engagement?.status,
                                                     )}
                                                 </span>
                                             </div>