Queue Order

app.py

@@ -252,7 +252,7 @@ def _dataframe(
         interactive=False,
         wrap=False,
         line_breaks=False,
-        column_widths=[column_width(column) for column in value.columns],
+        column_widths=[164 if column == "Status" and "queue-table" in classes else column_width(column) for column in value.columns],
         max_height=max_height,
         elem_classes=[*classes, "data-table"],
     )
@@ -1410,11 +1410,11 @@ with gr.Blocks(
             with gr.TabItem(group["tab"], id=index, elem_id=f"tab-{group['slug']}", **TAB_RENDER_OPTIONS):
                 with gr.Column(elem_id=f"task-page-{group['slug']}", elem_classes="task-page-shell"):
                     track_tabs, boards, task_selector = _render_subtasks(group["tasks"], group["title"])
-                    with gr.Row(elem_classes='queue-head-row'):
+                    with gr.Row(elem_classes='submission-center-shell') as submission_header:
                         evaluator_status = gr.Markdown('Evaluator Status: Unavailable', visible=False, elem_classes='markdown-text', elem_id=f'evaluator-status-{group["slug"]}')
-                        status_refresh = gr.Button('↻ Refresh', size='sm', scale=0, min_width=96, elem_classes='board-refresh', elem_id=f'evaluator-refresh-{group["slug"]}')
+                        status_refresh = gr.Button('↻ Refresh', visible=False, size='sm', scale=0, min_width=96, elem_classes='board-refresh', elem_id=f'evaluator-refresh-{group["slug"]}')
                     status_refresh_events.extend([(demo.load, evaluator_status), (status_refresh.click, evaluator_status)])
-                    with gr.Accordion(
+                    with submission_header, gr.Accordion(
                         'Submission Center', open=False,
                         elem_classes='submission-panel utility-panel', elem_id=f'submit-{group["slug"]}',
                     ):

frontend_interaction_browser_regression.py

@@ -81,6 +81,18 @@ async def browser_check(port, server_port, api, runtime, root):
 
         await command('Page.navigate', dict(url=f'http://127.0.0.1:{server_port}/ui/login/huggingface?_target_url=/ui/'))
         await wait("document.body.textContent.includes('audit-user')")
+        for width in (1440, 390):
+            await command('Emulation.setDeviceMetricsOverride', dict(width=width, height=1000, deviceScaleFactor=1, mobile=False))
+            for opened in (False, True):
+                state = await evaluate("""(() => {
+                    const shell=document.querySelector('.submission-center-shell');
+                    const header=shell.querySelector('.submission-panel > button.label-wrap');
+                    if (header.classList.contains('open')!==%s) header.click();
+                    return {visibleRefresh:Array.from(shell.querySelectorAll(':scope > button.board-refresh')).some(el=>el.getBoundingClientRect().height>0),
+                        titleFits:header.scrollWidth<=header.clientWidth+1};
+                })()""" % str(opened).lower())
+                assert not state['visibleRefresh'] and state['titleFits'], (width, opened, state)
+        print('PASS evaluator refresh hidden, desktop/mobile, expanded/collapsed, no header gap', flush=True)
         await evaluate("document.querySelector('.submission-panel > button').classList.contains('open') || document.querySelector('.submission-panel > button').click()")
         await wait("Array.from(document.querySelectorAll('.submission-panel .utility-tabs [role=tab]')).some(el=>el.textContent.trim()==='History & Reports')")
         await click("Array.from(document.querySelectorAll('.submission-panel .utility-tabs [role=tab]')).find(el=>el.textContent.trim()==='History & Reports')")

frontend_interaction_regression.py

@@ -142,7 +142,10 @@ class InteractionChecks(unittest.TestCase):
         self.assertIn('Novel View Synthesis', html)
         self.assertIn('0.000', html)
         record['metrics']['rendering_pmf'] = 0
-        self.assertIn('Rendering PMF', self.ui.render_submission_summary(record, {}))
+        with_overall = self.ui.render_submission_summary(record, {})
+        self.assertIn('Rendering PMF', with_overall)
+        self.assertIn('<h5>Overall Rendering Metrics</h5>', with_overall)
+        self.assertNotIn('<h5>Metrics</h5>', with_overall)
         self.assertEqual(record['metrics']['novel_pmf'], original['metrics']['novel_pmf'])
 
     def test_input_source_metadata_is_allowlisted_and_not_paper_or_code(self):
@@ -163,6 +166,9 @@ class InteractionChecks(unittest.TestCase):
         status = [item for item in components if (item['props'].get('elem_id') or '').startswith('evaluator-status-')]
         self.assertEqual(len(status), 4)
         self.assertTrue(all(item['props']['visible'] is False for item in status))
+        refresh = [item for item in components if (item['props'].get('elem_id') or '').startswith('evaluator-refresh-')]
+        self.assertEqual(len(refresh), 4)
+        self.assertTrue(all(item['props']['visible'] is False for item in refresh))
         text = (Path(__file__).parent/'app.py').read_text(encoding='utf-8')
         self.assertNotIn('Enter Method and User Dataset before submitting.', text)
         self.assertNotIn('Sign in with Hugging Face to create or load your Researcher Identity.', text)

queue_position_regression.py

@@ -0,0 +1,194 @@
+"""Synthetic global waiting-position tests; no Worker, Hub or production writes."""
+import ast
+from contextlib import ExitStack
+from datetime import datetime, timezone
+import json
+import os
+from pathlib import Path
+import tempfile
+import unittest
+from unittest.mock import patch
+
+import staging_regression as staging
+
+
+class QueuePositionChecks(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        staging.StagingChecks.setUpClass()
+        cls.ui = staging.StagingChecks.ui
+
+    @classmethod
+    def tearDownClass(cls):
+        staging.StagingChecks.tearDownClass()
+
+    def setUp(self):
+        from src.storage import local
+        from src.leaderboard import read_evals, queue_position
+        staging.StagingChecks().seed_identity()
+        self.local, self.reader, self.positions = local, read_evals, queue_position
+        self.owner = staging.StagingChecks.owner
+        self.identity = '0000-0002-1825-0097'
+        self.temporary = tempfile.TemporaryDirectory(prefix='phys-position-')
+        self.addCleanup(self.temporary.cleanup)
+        self.root = Path(self.temporary.name)
+        self.stack = self.enterContext(ExitStack())
+        for name, relative in dict(PENDING_DIR='pending', PROCESSING_DIR='processing', COMPLETE_DIR='complete',
+                                  PROGRESS_DIR='progress', DELETE_PENDING_DIR='deletions/pending',
+                                  DELETE_PROCESSING_DIR='deletions/processing').items():
+            directory = self.root/relative
+            directory.mkdir(parents=True, exist_ok=True)
+            self.stack.enter_context(patch.object(local, name, str(directory)))
+        (self.root/'deletions/complete').mkdir()
+        self.stack.enter_context(patch.object(read_evals, 'get_submitter', return_value=dict(researcher_identity_id=self.identity)))
+        self.stack.enter_context(patch.object(read_evals, 'hidden_submission_ids', return_value=set()))
+        self.marker = {}
+        self.stack.enter_context(patch.object(queue_position, '_read', side_effect=lambda: dict(orcid_maintenance=self.marker)))
+
+    def record(self, number, *, owner=None, task='motionTransfer', status='pending', managed=True, time=1):
+        sid = f'{number:010x}'
+        record = dict(submission_id=sid, task_name=task, status=status,
+                      researcher_identity_id=owner or self.identity, hf_subject='subject-'+str(number),
+                      display_name='Private method '+str(number), team_id='Private team '+str(number),
+                      submitted_at=f'2026-11-01T00:00:{time:02d}Z', scenes_total=4)
+        if managed:
+            record['evaluator_dispatch_ready'] = True
+        directory = 'processing' if status == 'running' else 'pending'
+        path = self.root/directory/(sid+'.json')
+        path.write_text(json.dumps(record), encoding='utf-8')
+        os.utime(path, (100+number, 100+number))
+        return record, path
+
+    def queue(self, tasks=None, limit=100):
+        return self.reader.load_queue_df(limit=limit, task_names=tasks or ['motionTransfer'], owner_username=self.owner).set_index('ID')
+
+    def test_empty_and_single(self):
+        self.assertTrue(self.queue().empty)
+        record, _ = self.record(1)
+        self.assertEqual(self.queue().loc[record['submission_id'], 'Status'], 'Queued · #1')
+
+    def test_global_users_tasks_ranked_before_private_filters_and_limit(self):
+        self.record(1, owner='other-identity', task='futurePrediction', time=1)
+        mine, _ = self.record(2, time=2)
+        other_task, _ = self.record(3, task='propertyEstimation', time=3)
+        last, _ = self.record(4, time=4)
+        rows = self.queue()
+        self.assertEqual(set(rows.index), {mine['submission_id'], last['submission_id']})
+        self.assertEqual(rows.loc[mine['submission_id'], 'Status'], 'Queued · #2')
+        self.assertEqual(rows.loc[last['submission_id'], 'Status'], 'Queued · #4')
+        self.assertNotIn('Private method 1', rows.to_json())
+        self.assertNotIn(other_task['submission_id'], rows.index)
+        self.assertEqual(self.queue(limit=1).iloc[0]['Status'], 'Queued · #4')
+
+    def test_worker_managed_time_legacy_mtime_and_filename_tie_break(self):
+        first, first_path = self.record(9, managed=False, time=59)
+        second, second_path = self.record(8, time=2)
+        third, third_path = self.record(7, time=2)
+        os.utime(second_path, (1, 1))
+        os.utime(third_path, (2, 2))
+        rows = self.queue()
+        for record, position in [(first, 1), (third, 2), (second, 3)]:
+            self.assertEqual(rows.loc[record['submission_id'], 'Status'], f'Queued · #{position}')
+        source = ast.parse((Path(__file__).parent.parent/'PhysInOne-Leaderboard-Worker/src/worker/lease.py').read_text(encoding='utf-8'))
+        claim = next(node for node in source.body if isinstance(node, ast.FunctionDef) and node.name == 'claim_one')
+        body = []
+        for node in claim.body:
+            if isinstance(node, ast.For) and isinstance(node.target, ast.Tuple):
+                break
+            body.append(node)
+        body.append(ast.Return(value=ast.Name(id='entries', ctx=ast.Load())))
+        function = ast.FunctionDef(name='worker_order', args=ast.arguments(posonlyargs=[], args=[], kwonlyargs=[], kw_defaults=[], defaults=[]), body=body, decorator_list=[])
+        module = ast.fix_missing_locations(ast.Module(body=[function], type_ignores=[]))
+        scope = dict(PENDING_DIR=str(self.root/'pending'), os=os,
+                     list_queue=lambda root: sorted(path.name for path in Path(root).glob('*.json')),
+                     read_json=lambda path: json.loads(Path(path).read_text()),
+                     parse_iso=lambda value: datetime.strptime(value, '%Y-%m-%dT%H:%M:%SZ').replace(tzinfo=timezone.utc))
+        exec(compile(module, '<readonly-worker-order>', 'exec'), scope)
+        expected = {entry[2]['submission_id']: index for index, entry in enumerate(scope['worker_order'](), 1)}
+        self.assertEqual(self.positions.waiting_positions(self.local.list_pending(), [], set()), expected)
+
+    def test_running_progress_excluded_and_position_moves_on_claim(self):
+        first, path = self.record(1)
+        second, _ = self.record(2, time=2)
+        first['status'] = 'running'
+        target = self.root/'processing'/path.name
+        target.write_text(json.dumps(first))
+        path.unlink()
+        (self.root/'progress'/path.name).write_text(json.dumps(dict(scene_results={'scene': {}})))
+        rows = self.queue()
+        self.assertEqual(rows.loc[first['submission_id'], 'Status'], 'Running')
+        self.assertEqual(rows.loc[first['submission_id'], 'Progress / Scenes'], '1/4')
+        self.assertEqual(rows.loc[second['submission_id'], 'Status'], 'Queued · #1')
+
+    def test_finished_cancelled_failed_leave_waiting_order(self):
+        for status in ('done', 'cancelled', 'failed'):
+            with self.subTest(status=status):
+                first, path = self.record(1)
+                second, second_path = self.record(2, time=2)
+                first['status'] = status
+                (self.root/'complete'/path.name).write_text(json.dumps(first))
+                path.unlink()
+                rows = self.queue()
+                self.assertEqual(list(rows.index), [second['submission_id']])
+                self.assertEqual(rows.iloc[0]['Status'], 'Queued · #1')
+                second_path.unlink()
+
+    def test_unready_head_is_not_skipped(self):
+        first, path = self.record(1)
+        first['evaluator_dispatch_ready'] = False
+        path.write_text(json.dumps(first))
+        second, _ = self.record(2, time=2)
+        rows = self.queue()
+        self.assertEqual(rows.loc[first['submission_id'], 'Status'], 'Queued · #1')
+        self.assertEqual(rows.loc[second['submission_id'], 'Status'], 'Queued · #2')
+
+    def test_maintenance_skips_affected_identity_and_hides_its_position(self):
+        first, _ = self.record(1)
+        second, _ = self.record(2, owner='other-identity', time=2)
+        self.marker = dict(phase='awaiting_oauth', old_orcid=self.identity, new_orcid='target', hf_subject='admin')
+        self.assertEqual(self.queue().loc[first['submission_id'], 'Status'], 'Queued')
+        self.assertEqual(self.positions.waiting_positions(self.local.list_pending(), [], set()), {second['submission_id']: 1})
+        self.marker['phase'] = 'applying'
+        self.assertEqual(self.positions.waiting_positions(self.local.list_pending(), [], set()), {})
+
+    def test_uncertain_order_omits_numbers(self):
+        record, _ = self.record(1)
+        with patch.object(self.positions.os.path, 'getmtime', side_effect=OSError('synthetic')):
+            record.pop('evaluator_dispatch_ready')
+            (self.root/'pending'/(record['submission_id']+'.json')).write_text(json.dumps(record))
+            self.assertEqual(self.queue().iloc[0]['Status'], 'Queued')
+        with patch.object(self.positions, '_read', side_effect=OSError('synthetic')):
+            self.assertEqual(self.queue().iloc[0]['Status'], 'Queued')
+
+    def test_pending_cancel_request_and_terminal_residual_are_not_guessed(self):
+        first, path = self.record(1)
+        self.record(2, time=2)
+        request = dict(first, request_id='abcdef', action='cancel_submission')
+        (self.root/'deletions/pending/abcdef.json').write_text(json.dumps(request))
+        self.assertTrue(all(value == 'Queued' for value in self.queue()['Status']))
+        (self.root/'deletions/pending/abcdef.json').unlink()
+        (self.root/'complete'/path.name).write_text(json.dumps(dict(first, status='done')))
+        self.assertTrue(all(value == 'Queued' for value in self.queue()['Status']))
+
+    def test_repeated_refresh_read_only_and_no_sleep_wake_calls(self):
+        self.record(1)
+        before = {str(path):(path.read_bytes(), path.stat().st_mtime_ns) for path in self.root.rglob('*') if path.is_file()}
+        from src.submission import evaluator_space
+        with patch.object(evaluator_space, 'HfApi', side_effect=AssertionError('must not contact Worker')), \
+                patch.object(evaluator_space, 'submission_enqueued', side_effect=AssertionError('must not write')):
+            for _ in range(3):
+                self.assertEqual(self.queue().iloc[0]['Status'], 'Queued · #1')
+        self.assertEqual(before, {str(path):(path.read_bytes(), path.stat().st_mtime_ns) for path in self.root.rglob('*') if path.is_file()})
+
+    def test_only_queue_status_width_changes(self):
+        from src.display.table_layout import column_width
+        self.assertEqual(column_width('Status'), 132)
+        components = self.ui.demo.config['components']
+        queue = next(item for item in components if item['type'] == 'dataframe' and 'queue-table' in item['props']['elem_classes'])
+        history = next(item for item in components if item['type'] == 'dataframe' and 'history-table' in item['props']['elem_classes'])
+        for item, width in ((queue, 164), (history, 132)):
+            self.assertEqual(item['props']['column_widths'][item['props']['headers'].index('Status')], f'{width}px')
+
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)

queue_refresh_regression.py

@@ -113,7 +113,7 @@ async def browser_check(port, server_port, api, runtime, root):
                 if await evaluate(f'Boolean(document.body && ({expression}))'):
                     return
                 await asyncio.sleep(.1)
-            raise AssertionError(expression)
+            raise AssertionError((expression, await evaluate("({queue:document.querySelector('#submit-video_generation')?.innerText.slice(-6000),tables:document.querySelectorAll('.queue-table').length})")))
 
         await command('Network.enable', {})
         await command('Network.setBlockedURLs', dict(urls=['https://*']))
@@ -124,13 +124,49 @@ async def browser_check(port, server_port, api, runtime, root):
         await evaluate("document.querySelector('#video_generation-utility-queue-button').click()")
         selector = '#video_generation-queue-refresh-button'
         await wait(f"document.querySelector('{selector}')?.getBoundingClientRect().height>0")
+        from src import envs
+        from src.submission import evaluator_space
+        runtime.stage = 'SLEEPING'
+        fixture_task = next(iter(ui.TASKS))
+        foreign = dict(submission_id='a111111111', task_name='futurePrediction', status='queued',
+                       researcher_identity_id='private-other-user', display_name='PRIVATE_OTHER_METHOD',
+                       submitted_at='2026-11-01T00:00:01Z', evaluator_dispatch_ready=True)
+        mine = dict(foreign, submission_id='a222222222', task_name=fixture_task,
+                    researcher_identity_id='0000-0002-1825-0097', display_name='Queue fixture',
+                    submitted_at='2026-11-01T00:00:02Z')
+        running = dict(mine, submission_id='a333333333', status='running', scenes_total=4)
+        for directory, record in ((envs.PENDING_DIR, foreign), (envs.PENDING_DIR, mine), (envs.PROCESSING_DIR, running)):
+            (Path(directory)/(record['submission_id']+'.json')).write_text(json.dumps(record))
+        (Path(envs.PROGRESS_DIR)/(running['submission_id']+'.json')).write_text(json.dumps(dict(scene_results={'scene': {}})))
+        with patch.object(evaluator_space, 'HfApi', side_effect=AssertionError('Queue refresh must not contact Worker')):
+            await asyncio.sleep(.6)
+            await evaluate("document.querySelector('#video_generation-utility-queue-button').click()")
+            await wait("document.querySelector('#submit-video_generation .queue-table')")
+            await evaluate(f"document.querySelector('{selector}').click()")
+            await wait("document.querySelector('#submit-video_generation .queue-table')?.textContent.includes('Queued · #2')")
+            assert not await evaluate("document.querySelector('#submit-video_generation .queue-table').textContent.includes('PRIVATE_OTHER_METHOD')")
+            for width in (1440, 390):
+                await command('Emulation.setDeviceMetricsOverride', dict(width=width, height=900, deviceScaleFactor=1, mobile=False))
+                await asyncio.sleep(.2)
+                assert await evaluate("""(() => {
+                    const table=document.querySelector('#submit-video_generation .queue-table table:not([aria-hidden=true])');
+                    const column=Array.from(table.querySelectorAll('thead th')).findIndex(el=>el.textContent.includes('Status'));
+                    return Array.from(table.tBodies[0].rows).every(row=>row.cells[column].scrollWidth<=row.cells[column].clientWidth+1)
+                        &&table.textContent.includes('Queued · #2')&&table.textContent.includes('Running')&&table.textContent.includes('1/4');
+                })()"""), width
+            foreign['status'] = 'running'
+            (Path(envs.PROCESSING_DIR)/(foreign['submission_id']+'.json')).write_text(json.dumps(foreign))
+            (Path(envs.PENDING_DIR)/(foreign['submission_id']+'.json')).unlink()
+            await evaluate(f"document.querySelector('{selector}').click()")
+            await wait("document.querySelector('#submit-video_generation .queue-table')?.textContent.includes('Queued · #1')")
+        print('PASS global queue positions #2 -> #1, private rows hidden, Running progress retained, desktop/mobile Status fits, Sleeping Worker never contacted', flush=True)
         for width in (1440, 390):
             await command('Emulation.setDeviceMetricsOverride', dict(width=width, height=900, deviceScaleFactor=1, mobile=False))
             await evaluate(f"document.querySelector('{selector}').scrollIntoView({{block:'center'}})")
             await asyncio.sleep(.2)
             assert await evaluate(f"""(() => {{const button=document.querySelector('{selector}'),box=button.getBoundingClientRect(),title=button.parentElement.querySelector('.submission-section-title').getBoundingClientRect();
                 return box.x>=title.right-1 && [.1,.5,.9].every(fraction=>{{const hit=document.elementFromPoint(box.x+box.width*fraction,box.y+box.height/2);return button===hit||button.contains(hit)}});}})()"""), width
-        frame = ui._safe_queue([next(iter(ui.TASKS))], staging.StagingChecks.owner)
+        frame = ui._safe_queue([next(iter(ui.TASKS))], staging.StagingChecks.owner).iloc[:0].copy()
         record = {column: '' for column in frame.columns}
         record.update(ID='123456abcd', Task=next(iter(ui.TASKS)), Status='running')
         live = pd.DataFrame([record], columns=frame.columns)

src/display/academic.py

@@ -294,6 +294,8 @@ button.open-submission:hover { box-shadow: 0 5px 18px rgba(99,102,241,.28) !impo
 .gradio-container #main-tabs .task-page-shell button.board-refresh { display: inline-flex !important; align-items: center !important; justify-content: center !important; gap: 6px !important; flex: 0 0 auto !important; width: auto !important; min-width: 0 !important; min-height: 32px !important; padding: 4px 10px !important; border: 1px solid #e5e2f0 !important; border-radius: 7px !important; background: #fff !important; color: #5149b8 !important; box-shadow: none !important; font-size: 12px !important; font-weight: 500 !important; line-height: 20px !important; }
 .gradio-container #main-tabs .task-page-shell button.board-refresh:hover { background: #f1efff !important; color: #6366f1 !important; }
 .gradio-container #main-tabs .task-page-shell button.board-refresh:disabled { opacity: .5 !important; cursor: not-allowed; }
+.gradio-container #main-tabs .submission-center-shell { position: relative; gap: 0 !important; padding: 0 !important; }
+.gradio-container #main-tabs .submission-center-shell > .submission-panel { flex: 1 1 100%; width: 100%; min-width: 0 !important; }
 .public-leaderboard { margin: 0 !important; padding: 0 !important; border: 0 !important; overflow: visible !important; }
 .public-leaderboard > .html-container { padding: 0 !important; min-width: 0; overflow: visible !important; }
 .public-leaderboard .board-scroll { overflow: auto !important; width: 100%; border: 1px solid #e0ddf0; border-radius: 15px; background: #ffffff; box-shadow: 0 5px 18px rgba(30,41,59,.035),0 0 22px rgba(139,92,246,.035); scrollbar-width: thin; scrollbar-color: #d6d7e5 transparent; }

src/display/table_layout.py

@@ -125,7 +125,7 @@ table_resize_js = r"""() => {
                         }
                     });
                     if (!saved.has(index)) {
-                        saved.set(index, Math.max(minimumFor(name), initialWidthFor(name)));
+                        saved.set(index, Math.max(minimumFor(name), name === 'Status' && component.classList.contains('queue-table') ? 164 : initialWidthFor(name)));
                     }
                     if (header.querySelector('.column-resize-handle')) return;
                     const setWidth = requested => {

src/leaderboard/queue_position.py

@@ -0,0 +1,66 @@
+"""Read-only pending positions matching Worker claim_one ordering."""
+from datetime import datetime, timezone
+import logging
+import math
+import os
+from pathlib import Path
+import re
+
+from src.storage import local
+from src.submission.management_queue import active_requests
+from src.submission.registry import _read
+
+logger = logging.getLogger(__name__)
+
+
+def waiting_positions(pending: list[dict], processing: list[dict], terminal_ids: set[str]) -> dict[str, int]:
+    if not pending:
+        return {}
+    try:
+        names = local._list_json(local.PENDING_DIR, strict=True)
+        by_id = {record.get('submission_id'): record for record in pending}
+        if (len(by_id) != len(pending) or any(not isinstance(sid, str) or not re.fullmatch(r'[0-9a-f]{10}', sid) for sid in by_id)
+                or set(names) != {sid+'.json' for sid in by_id}):
+            return {}
+        processing_ids = {record.get('submission_id') for record in processing}
+        maintenance = _read().get('orcid_maintenance') or {}
+        if not isinstance(maintenance, dict) or maintenance.get('phase') == 'applying':
+            return {}
+
+        def blocked(record):
+            return bool(maintenance and (record.get('researcher_identity_id') in
+                        (maintenance.get('old_orcid'), maintenance.get('new_orcid'))
+                        or record.get('hf_subject') == maintenance.get('hf_subject')))
+
+        requests = active_requests(local.DELETE_PENDING_DIR, local.DELETE_PROCESSING_DIR,
+                                   Path(local.DELETE_PENDING_DIR).parent/'complete')
+        for _, request in requests:
+            record = by_id.get(request.get('submission_id'))
+            if (record and not blocked(request) and request.get('action') in {'cancel_pending', 'cancel_submission'}
+                    and request.get('researcher_identity_id')
+                    and all(record.get(key) == request.get(key) for key in ('task_name', 'researcher_identity_id'))):
+                return {}
+        entries = []
+        for sid, record in by_id.items():
+            if sid in terminal_ids or sid in processing_ids:
+                return {}
+            if record.get('status') not in {'pending', 'queued'} or record.get('cancel_requested_at'):
+                return {}
+            if blocked(record):
+                continue
+            submitted = None
+            if 'evaluator_dispatch_ready' in record:
+                try:
+                    submitted = datetime.strptime(record.get('submitted_at'), '%Y-%m-%dT%H:%M:%SZ').replace(tzinfo=timezone.utc)
+                except (TypeError, ValueError):
+                    pass
+            order = submitted.timestamp() if submitted else os.path.getmtime(os.path.join(local.PENDING_DIR, sid+'.json'))
+            if not math.isfinite(order):
+                return {}
+            entries.append((order, sid))
+        if names != local._list_json(local.PENDING_DIR, strict=True):
+            return {}
+        return {sid: index for index, (_, sid) in enumerate(sorted(entries), 1)}
+    except (OSError, ValueError, TypeError):
+        logger.warning('Waiting queue order unavailable; omitting precise positions')
+        return {}

src/leaderboard/read_evals.py

@@ -25,6 +25,7 @@ from src.submission.public_metrics import public_metric_groups
 from src.submission.status import display_submission_status, is_active_submission, is_terminal_submission
 from src.submission.registry import get_submitter
 from src.submission.publication import published_entries
+from src.leaderboard.queue_position import waiting_positions
 
 logger = logging.getLogger(__name__)
 
@@ -322,6 +323,7 @@ def load_queue_df(
     for record in all_processing:
         if record.get('submission_id') and is_terminal_submission(record.get('status')):
             completed_by_id.setdefault(record['submission_id'], record)
+    positions = waiting_positions(all_pending, all_processing, set(completed_by_id))
     all_processing = [record for record in all_processing if record.get('submission_id') not in completed_by_id and is_active_submission(record.get('status') or 'running')]
     active_ids = {record.get('submission_id') for record in all_processing}
     all_pending = [record for record in all_pending if record.get('submission_id') not in completed_by_id and record.get('submission_id') not in active_ids and is_active_submission(record.get('status') or 'pending')]
@@ -334,19 +336,24 @@ def load_queue_df(
     rows: list[dict] = []
 
     for record in pending:
+        status = display_submission_status({**record, "status": record.get("status") or "pending"})
+        if status in {"pending", "queued"}:
+            position = positions.get(record.get("submission_id"))
+            status = f"Queued · #{position}" if position else "Queued"
         rows.append({
             "Submitted At": record.get("submitted_at"),
             "ID": record.get("submission_id"),
             "Submitter": normalize_submission_identity(record)["team_name"],
             "Method / Model": normalize_submission_identity(record)["method_name"],
             "Task": record.get("task_name"),
-            "Status": display_submission_status({**record, "status": record.get("status") or "pending"}),
+            "Status": status,
             "Progress / Scenes": "-",
             "Score": None,
         })
 
     for record in processing:
         submission_id = record.get("submission_id")
+        status = display_submission_status({**record, "status": record.get("status") or "running"})
         progress = read_progress(submission_id, strict=True) or {}
         done = len(progress.get("scene_results") or {})
         scene_failures = progress.get("scene_failures") or {}
@@ -357,7 +364,7 @@ def load_queue_df(
             "Submitter": normalize_submission_identity(record)["team_name"],
             "Method / Model": normalize_submission_identity(record)["method_name"],
             "Task": record.get("task_name"),
-            "Status": display_submission_status({**record, "status": record.get("status") or "running"}),
+            "Status": "Running" if status == "running" else status,
             "Progress / Scenes": _scenes_str(done, failed, record.get("scenes_total")),
             "Score": None,
         })

src/submission/summary.py

@@ -100,7 +100,8 @@ def render_submission_summary(record: dict, links: dict, snapshot: dict | None =
         if task.name == "propertyEstimation" and title in material_groups:
             metric_groups.append(f'<details class="selected-metric-group"><summary>{escape(title)}</summary><div>{items}</div></details>')
         else:
-            metric_groups.append(f'<section class="selected-metric-group"><h5>{escape(title)}</h5><div>{items}</div></section>')
+            display_title = "Overall Rendering Metrics" if task.name == "propertyEstimation" and title == "Metrics" else title
+            metric_groups.append(f'<section class="selected-metric-group"><h5>{escape(display_title)}</h5><div>{items}</div></section>')
 
     links_html = []
     for kind in ("paper", "code"):