diff --git a/nginx.conf b/nginx.conf
index eb25c72cf..fe5386233 100644
--- a/nginx.conf
+++ b/nginx.conf
@@ -38,4 +38,12 @@ server {
         index index.html;
         try_files $uri $uri/ /index.html;
     }
+
+    # the page itself is checked on every load, so a deploy reaches browsers at once; the scripts it loads have
+    # hashed names and may stay cached. add_header here replaces the server's ones, hence HSTS again
+    location = /index.html {
+        root /usr/share/nginx/html;
+        add_header Cache-Control "no-cache" always;
+        add_header Strict-Transport-Security "max-age=63072000" always;
+    }
 }
\ No newline at end of file
diff --git a/src/JsRoot/GraphData.tsx b/src/JsRoot/GraphData.tsx
index ea9c8796f..282b11ee2 100644
--- a/src/JsRoot/GraphData.tsx
+++ b/src/JsRoot/GraphData.tsx
@@ -61,6 +61,7 @@ export type Estimator = {
 	name: string;
 	metadata?: unknown;
 	pages: Page[];
+	outputUuid?: string;
 	scoringOutputJsonRef?: ScoringOutputJSON;
 };
 
diff --git a/src/WrapperApp/components/Results/EstimatorsSelect/EstimatorsSelect.tsx b/src/WrapperApp/components/Results/EstimatorsSelect/EstimatorsSelect.tsx
index f7e4a1d04..6db58bc3b 100644
--- a/src/WrapperApp/components/Results/EstimatorsSelect/EstimatorsSelect.tsx
+++ b/src/WrapperApp/components/Results/EstimatorsSelect/EstimatorsSelect.tsx
@@ -1,5 +1,5 @@
 import { useTheme } from '@mui/material';
-import { SyntheticEvent, useCallback, useEffect, useState } from 'react';
+import { SyntheticEvent, useCallback, useEffect, useRef, useState } from 'react';
 
 import { useRemoteWorkerSimulation } from '../../../../services/RemoteWorkerSimulationContextProvider';
 import { ResultsSimulationDataWithSource } from '../../../../services/StoreService';
@@ -7,6 +7,7 @@ import { StyledTab, StyledTabs } from '../../../../shared/components/Tabs/Styled
 import { SpecificEstimator } from '../../../../types/RequestTypes';
 import { EstimatorPagesByDimensions } from '../../../../types/ResponseTypes';
 import { FullSimulationData } from '../../../../types/SimulationService';
+import { partialRevision } from '../../../../util/partialResults';
 
 interface EstimatorsTabProps {
 	tabsValue: number;
@@ -31,12 +32,23 @@ const EstimatorsSelect = ({
 	const [controller] = useState(new AbortController());
 
 	const { getEstimatorsPages } = useRemoteWorkerSimulation();
+	const revision = partialRevision(simulation);
+	// the partial results revision each tab was loaded at, so a newer partial or the final results load it again;
+	// the estimators there at mount were loaded at the revision then (the component is keyed by simulation)
+	const loadedRevisions = useRef(new Map<number, number | undefined>());
+	const mountRevision = useRef(revision);
 
 	const handleEstimatorTabChange = useCallback(
-		async (id: number) => {
+		async (id: number, isStale: () => boolean) => {
 			const currentEstimatorData = simulation.estimators;
+			const loadedRevision = loadedRevisions.current.has(id)
+				? loadedRevisions.current.get(id)
+				: mountRevision.current;
+
 			const estimatorExists =
-				currentEstimatorData[id] && currentEstimatorData[id].name !== '';
+				currentEstimatorData[id] &&
+				currentEstimatorData[id].name !== '' &&
+				loadedRevision === revision;
 
 			if (estimatorsPagesData) {
 				const estimatorsPagesByDimensions = estimatorsPagesData[id].pagesByDimensions;
@@ -50,7 +62,8 @@ const EstimatorsSelect = ({
 							{
 								jobId: simulationJobId,
 								estimatorName: estimatorsTabData[id],
-								pageNumbers: pageDimension.pageNums
+								pageNumbers: pageDimension.pageNums,
+								revision
 							},
 							controller.signal,
 							true
@@ -61,7 +74,8 @@ const EstimatorsSelect = ({
 						}
 					}
 
-					if (allResults.length === 0) return;
+					// a newer simulation or tab is being loaded meanwhile
+					if (allResults.length === 0 || isStale()) return;
 
 					const aggregationResults = allResults.reduce(
 						(acc, result) => {
@@ -97,7 +111,9 @@ const EstimatorsSelect = ({
 						...simulation,
 						estimators: newEstimators
 					};
-					setResultsSimulationData({ source: 'onSelect', data: newSimulation });
+					loadedRevisions.current.set(id, revision);
+					// not onSelect: a new partial loaded while another screen is open must not switch to Results
+					setResultsSimulationData({ source: 'onLoad', data: newSimulation });
 				}
 			}
 		},
@@ -106,14 +122,21 @@ const EstimatorsSelect = ({
 			estimatorsPagesData,
 			estimatorsTabData,
 			getEstimatorsPages,
+			revision,
 			setResultsSimulationData,
 			simulation
 		]
 	);
 
+	// the tab on screen, whenever it or the simulation changes
 	useEffect(() => {
-		handleEstimatorTabChange(0);
-	}, [handleEstimatorTabChange]);
+		let stale = false;
+		handleEstimatorTabChange(tabsValue, () => stale);
+
+		return () => {
+			stale = true;
+		};
+	}, [handleEstimatorTabChange, tabsValue]);
 
 	const handleChange = (_event: SyntheticEvent, newValue: number) => {
 		setTabsValue(newValue);
@@ -131,7 +154,6 @@ const EstimatorsSelect = ({
 						key={`tab_${estimatorName}`}
 						label={estimatorName}
 						value={id}
-						onClick={() => handleEstimatorTabChange(id)}
 					/>
 				);
 			})}
diff --git a/src/WrapperApp/components/Results/ResultsPanel.tsx b/src/WrapperApp/components/Results/ResultsPanel.tsx
index 5ed575aca..c181b2391 100644
--- a/src/WrapperApp/components/Results/ResultsPanel.tsx
+++ b/src/WrapperApp/components/Results/ResultsPanel.tsx
@@ -17,8 +17,10 @@ import { useStore } from '../../../services/StoreService';
 import { InfoTooltip } from '../../../shared/components/tooltip/InfoTooltip';
 import { titleToKebabCase } from '../../../ThreeEditor/components/Dialog/CustomDialog';
 import { FullSimulationData } from '../../../types/SimulationService';
+import { partialResultsLabel } from '../../../util/partialResults';
 import EstimatorsSelect from './EstimatorsSelect/EstimatorsSelect';
 import EstimatorTab from './EstimatorTab/EstimatorTab';
+import { useFollowPartialResults } from './useFollowPartialResults';
 
 export interface EstimatorResults extends Estimator {
 	tablePages: Page0D[];
@@ -38,8 +40,29 @@ function ResultsPanel(props: { simulation: FullSimulationData | undefined }) {
 	const { simulation } = props;
 
 	const [tabsValue, setTabsValue] = useState(0);
+	// another simulation starts at its first estimator; reset while rendering, before EstimatorsSelect loads a tab
+	const [shownJobId, setShownJobId] = useState(simulation?.jobId);
+
+	if (simulation?.jobId !== shownJobId) {
+		setShownJobId(simulation?.jobId);
+		setTabsValue(0);
+	}
+
 	const [estimatorsResults, setEstimatorsResults] = useState<EstimatorResults[]>([]);
 	const [groupQuantities, setGroupQuantities] = useState(false);
+	// re-rendered now and then, so the age of partial results stays right between updates
+	const [, setNow] = useState(Date.now());
+	const partialLabel = simulation && partialResultsLabel(simulation);
+	const isPartial = partialLabel !== undefined;
+
+	useFollowPartialResults(simulation);
+
+	useEffect(() => {
+		if (!isPartial) return;
+		const timer = setInterval(() => setNow(Date.now()), 30000);
+
+		return () => clearInterval(timer);
+	}, [isPartial]);
 
 	const userTabInputFilesEstimatorNames = simulation?.input.estimatorsItems?.map(
 		estimator => estimator.name
@@ -121,6 +144,13 @@ function ResultsPanel(props: { simulation: FullSimulationData | undefined }) {
 							lineHeight={2}>
 							{title}
 						</Typography>
+						{partialLabel && (
+							<Typography
+								variant='body2'
+								color='warning.main'>
+								Partial results: {partialLabel}
+							</Typography>
+						)}
 						<Divider />
 					</Box>
 					<Box
@@ -171,6 +201,7 @@ function ResultsPanel(props: { simulation: FullSimulationData | undefined }) {
 			{estimatorsResults.length > 0 && simulation && (
 				<>
 					<EstimatorsSelect
+						key={simulation.jobId}
 						tabsValue={tabsValue}
 						setTabsValue={setTabsValue}
 						simulation={simulation}
diff --git a/src/WrapperApp/components/Results/useFollowPartialResults.ts b/src/WrapperApp/components/Results/useFollowPartialResults.ts
new file mode 100644
index 000000000..7dade9bb2
--- /dev/null
+++ b/src/WrapperApp/components/Results/useFollowPartialResults.ts
@@ -0,0 +1,36 @@
+import { useEffect, useRef } from 'react';
+
+import { useRemoteWorkerSimulation } from '../../../services/RemoteWorkerSimulationContextProvider';
+import { useStore } from '../../../services/StoreService';
+import { withStatus } from '../../../services/useSimulationStatusStream';
+import { FullSimulationData } from '../../../types/SimulationService';
+import { partialRevision } from '../../../util/partialResults';
+
+/**
+ * Keeps the results on screen up to date with the status the server pushes (useSimulationStatusStream): a new
+ * partial, the final results, or a failed or canceled run replaces the shown status, and EstimatorsSelect loads the
+ * estimator on screen again when the partial results changed.
+ */
+export function useFollowPartialResults(simulation: FullSimulationData | undefined) {
+	const { statusStream } = useRemoteWorkerSimulation();
+	const { setResultsSimulationData } = useStore();
+	// read when a status comes, so updating the results does not apply the same status again
+	const latest = useRef(simulation);
+	latest.current = simulation;
+
+	const jobId = simulation?.jobId;
+	const status = jobId === undefined ? undefined : statusStream?.statuses[jobId];
+
+	useEffect(() => {
+		const shown = latest.current;
+
+		if (!status || shown?.jobId !== status.jobId) return;
+		const updated = withStatus(shown, status);
+
+		if (
+			updated.jobState !== shown.jobState ||
+			partialRevision(updated) !== partialRevision(shown)
+		)
+			setResultsSimulationData({ source: 'onLoad', data: updated });
+	}, [status, setResultsSimulationData]);
+}
diff --git a/src/WrapperApp/components/Simulation/SimulationCard/SimulationCardActions.tsx b/src/WrapperApp/components/Simulation/SimulationCard/SimulationCardActions.tsx
index 86ad47c28..1704f4fb9 100644
--- a/src/WrapperApp/components/Simulation/SimulationCard/SimulationCardActions.tsx
+++ b/src/WrapperApp/components/Simulation/SimulationCard/SimulationCardActions.tsx
@@ -11,6 +11,7 @@ import {
 	SimulationInputFiles,
 	StatusState
 } from '../../../../types/ResponseTypes';
+import { partialRevision } from '../../../../util/partialResults';
 
 interface SimulationCardActionsProps {
 	simulationStatus: Omit<JobUnknownStatus & SimulationInfo, never>;
@@ -96,11 +97,24 @@ export const SimulationCardActions = ({
 		}
 	}
 
+	// results stored while the simulation ran, kept when it was cancelled or failed
+	const partialAction = partialRevision(simulationStatus) !== undefined && (
+		<Button
+			sx={{ fontSize: '.8em' }}
+			size='small'
+			color='secondary'
+			disabled={!Boolean(loadResults)}
+			onClick={onClickLoadResults}>
+			Partial Results
+		</Button>
+	);
+
 	return (
 		<CardActions sx={{ p: 1 }}>
 			<ButtonGroup
 				fullWidth
 				aria-label='full width outlined button group'>
+				{partialAction}
 				{statusAction}
 				<Button
 					sx={{ fontSize: '.8em' }}
diff --git a/src/WrapperApp/components/Simulation/SimulationCard/SimulationCardContent.tsx b/src/WrapperApp/components/Simulation/SimulationCard/SimulationCardContent.tsx
index 0b453a672..53a2a1a33 100644
--- a/src/WrapperApp/components/Simulation/SimulationCard/SimulationCardContent.tsx
+++ b/src/WrapperApp/components/Simulation/SimulationCard/SimulationCardContent.tsx
@@ -1,14 +1,10 @@
 import { Box, CardContent, Chip, LinearProgress, Typography } from '@mui/material';
 import { useEffect, useState } from 'react';
 
-import {
-	currentJobStatusData,
-	currentTaskStatusData,
-	JobUnknownStatus,
-	SimulationInfo,
-	StatusState,
-	TaskUnknownStatus
-} from '../../../../types/ResponseTypes';
+import { JobUnknownStatus, SimulationInfo, StatusState } from '../../../../types/ResponseTypes';
+import { clusterBusyLabel } from '../../../../util/clusterBusy';
+import { partialResultsLabel } from '../../../../util/partialResults';
+import { TaskTotals, taskTotals } from '../../../../util/taskTotals';
 import { millisecondsToTimeString } from '../../../../util/time';
 
 interface SimulationCardContentProps {
@@ -20,38 +16,10 @@ interface SimulationCardContentProps {
 	highlightColor: string;
 }
 
-function getValidatedPrimaries(primariesNumber: number | undefined): number {
-	return primariesNumber ?? 0;
-}
-
-function percentOfSimulatedPrimaries(
-	requestedPrimariesSum: number,
-	simulatedPrimariesSum: number
-): number {
-	return requestedPrimariesSum > 0
-		? Math.min(100, (simulatedPrimariesSum / requestedPrimariesSum) * 100)
-		: 0;
-}
-
-function calculateSimulationProgress(jobTasksStatus: TaskUnknownStatus[]): number {
-	if (jobTasksStatus.length === 0) {
-		return 0;
-	}
-
-	const { requestedPrimariesSum, simulatedPrimariesSum } = jobTasksStatus.reduce(
-		(
-			acc: { requestedPrimariesSum: number; simulatedPrimariesSum: number },
-			taskStatus: TaskUnknownStatus
-		) => {
-			acc.requestedPrimariesSum += getValidatedPrimaries(taskStatus.requestedPrimaries);
-			acc.simulatedPrimariesSum += getValidatedPrimaries(taskStatus.simulatedPrimaries);
+function simulationProgress(totals: TaskTotals | undefined): number {
+	if (!totals || totals.requestedPrimaries <= 0) return 0;
 
-			return acc;
-		},
-		{ requestedPrimariesSum: 0, simulatedPrimariesSum: 0 }
-	);
-
-	return percentOfSimulatedPrimaries(requestedPrimariesSum, simulatedPrimariesSum);
+	return Math.min(100, (totals.simulatedPrimaries / totals.requestedPrimaries) * 100);
 }
 
 function needsProgressBar(state: StatusState | undefined) {
@@ -72,10 +40,7 @@ export function SimulationProgress(props: {
 	const [simulationProgressPercent, setSimulationProgressPercent] = useState(0);
 
 	useEffect(() => {
-		if (simulationStatus.jobTasksStatus) {
-			const jobTasksStatus = simulationStatus.jobTasksStatus;
-			setSimulationProgressPercent(calculateSimulationProgress(jobTasksStatus));
-		}
+		setSimulationProgressPercent(simulationProgress(taskTotals(simulationStatus)));
 	}, [simulationStatus, setSimulationProgressPercent]);
 
 	return (
@@ -110,6 +75,10 @@ export const SimulationCardContent = ({
 	simulationStatus,
 	highlightColor
 }: SimulationCardContentProps) => {
+	const totals = taskTotals(simulationStatus);
+	const partialLabel = partialResultsLabel(simulationStatus);
+	const busyLabel = clusterBusyLabel(simulationStatus);
+
 	return (
 		<CardContent sx={{ flexGrow: 1, p: 0, px: 1 }}>
 			<Box
@@ -127,29 +96,17 @@ export const SimulationCardContent = ({
 					}
 					sx={{ backgroundColor: highlightColor, color: 'white' }}
 				/>
-				{currentJobStatusData['hasSpecificProperty'](
-					simulationStatus,
-					'jobTasksStatus'
-				) && (
+				{totals && (
 					<>
 						<Chip
 							variant='outlined'
 							size='small'
-							label={`primaries: ${simulationStatus.jobTasksStatus.reduce(
-								(acc, taskStatus) =>
-									currentTaskStatusData['hasSpecificProperty'](
-										taskStatus,
-										'requestedPrimaries'
-									)
-										? acc + taskStatus.requestedPrimaries
-										: acc,
-								0 as number
-							)}`}
+							label={`primaries: ${totals.requestedPrimaries}`}
 						/>
 						<Chip
 							variant='outlined'
 							size='small'
-							label={`ntask: ${simulationStatus.jobTasksStatus.length}`}
+							label={`ntask: ${totals.ntasks}`}
 						/>
 					</>
 				)}
@@ -167,10 +124,7 @@ export const SimulationCardContent = ({
 			</Box>
 			<Box sx={{ minHeight: '40px' }}>
 				{needsProgressBar(simulationStatus.jobState)
-					? currentJobStatusData['hasSpecificProperty'](
-							simulationStatus,
-							'jobTasksStatus'
-						) && (
+					? totals && (
 							<SimulationProgress
 								formatedStartDate={formatedStartDate}
 								duration={duration}
@@ -192,6 +146,18 @@ export const SimulationCardContent = ({
 								</Typography>
 							</>
 						)}
+				{partialLabel && (
+					<Typography color='textDisabled'>Partial results: {partialLabel}</Typography>
+				)}
+				{busyLabel && <Typography color='warning.main'>{busyLabel}</Typography>}
+				{busyLabel && simulationStatus.clusterNotice && (
+					<Typography
+						variant='caption'
+						color='textSecondary'
+						sx={{ whiteSpace: 'pre-line' }}>
+						{simulationStatus.clusterNotice}
+					</Typography>
+				)}
 			</Box>
 		</CardContent>
 	);
diff --git a/src/WrapperApp/components/Simulation/SimulationsGrid/SimulationsGridHelpers.ts b/src/WrapperApp/components/Simulation/SimulationsGrid/SimulationsGridHelpers.ts
index de272b727..1a9caaf7a 100644
--- a/src/WrapperApp/components/Simulation/SimulationsGrid/SimulationsGridHelpers.ts
+++ b/src/WrapperApp/components/Simulation/SimulationsGrid/SimulationsGridHelpers.ts
@@ -1,6 +1,7 @@
-import { ChangeEvent, useCallback, useMemo, useRef, useState } from 'react';
+import { ChangeEvent, useCallback, useEffect, useMemo, useRef, useState } from 'react';
 
 import { isFullSimulationData } from '../../../../services/LoaderService';
+import { withStatus } from '../../../../services/useSimulationStatusStream';
 import { OrderBy, OrderType } from '../../../../types/RequestTypes';
 import {
 	currentJobStatusData,
@@ -10,6 +11,7 @@ import {
 	StatusState
 } from '../../../../types/ResponseTypes';
 import { FullSimulationData } from '../../../../types/SimulationService';
+import { partialRevision } from '../../../../util/partialResults';
 import { PageNavigationProps, PageParamProps } from '../SimulationPanelBar';
 import {
 	PageState,
@@ -18,6 +20,8 @@ import {
 	SimulationState
 } from './SimulationsGridTypes';
 
+const FINAL_STATES = new Set([StatusState.COMPLETED, StatusState.FAILED, StatusState.CANCELED]);
+
 const SimulationsGridHelpers = (
 	config: SimulationConfig,
 	handlers: SimulationHandlers,
@@ -26,8 +30,17 @@ const SimulationsGridHelpers = (
 	const [isModalOpen, setIsModalOpen] = useState<boolean>(false);
 	const currentJobId = useRef<string>('');
 	const { controller, trackedId, isBackendAlive, statusStates } = config;
-	const { getPageContents, getPageStatus, getJobStatus, getFullSimulationData, cancelJob } =
-		handlers;
+	const {
+		getPageContents,
+		getPageStatus,
+		getJobStatus,
+		getFullSimulationData,
+		cancelJob,
+		statusStream
+	} = handlers;
+	// read when a fetched status comes, so a status pushed meanwhile is not overwritten by an older one
+	const streamed = useRef(statusStream?.statuses);
+	streamed.current = statusStream?.statuses;
 
 	const {
 		simulationInfo,
@@ -61,7 +74,12 @@ const SimulationsGridHelpers = (
 
 	const handleBeforeCacheWrite = useCallback(
 		async (id: string, response: JobStatusData) => {
-			if (id === trackedId && currentJobStatusData[StatusState.COMPLETED](response)) {
+			if (
+				id === trackedId &&
+				currentJobStatusData[StatusState.COMPLETED](response) &&
+				!runFinishShown.has(id)
+			) {
+				runFinishShown.add(id);
 				const fullData = await getFullSimulationData(response, controller.signal);
 				setResultsSimulationData(
 					fullData ? { source: 'onRunFinish', data: fullData } : undefined
@@ -71,19 +89,32 @@ const SimulationsGridHelpers = (
 		[controller.signal, getFullSimulationData, setResultsSimulationData, trackedId]
 	);
 
+	const streamOpened = statusStream?.opened;
 	const updateSimulationData = useCallback(
 		() =>
-			getPageStatus(simulationInfo, true, handleBeforeCacheWrite, controller.signal).then(
-				s => {
-					setSimulationsStatusData([...(s ?? [])]);
-				}
-			),
+			// a tab nobody looks at does not poll; the next tick after it is shown again catches up
+			document.hidden && !statusStream?.live
+				? Promise.resolve()
+				: getPageStatus(
+						simulationInfo,
+						true,
+						handleBeforeCacheWrite,
+						controller.signal
+					).then(s => {
+						setSimulationsStatusData(
+							(s ?? []).map(data => withStatus(data, streamed.current?.[data.jobId]))
+						);
+					}),
+		// fetched again whenever the stream (re)opens: it sends only the simulations not finished by then
+		// eslint-disable-next-line react-hooks/exhaustive-deps
 		[
 			getPageStatus,
 			simulationInfo,
 			handleBeforeCacheWrite,
 			controller.signal,
-			setSimulationsStatusData
+			setSimulationsStatusData,
+			statusStream?.live,
+			streamOpened
 		]
 	);
 
@@ -113,8 +144,30 @@ const SimulationsGridHelpers = (
 		]
 	);
 
+	// pushed statuses in place of the held ones; a final one is fetched once, also to load the results of the
+	// tracked simulation
+	const fetchedFinal = useRef(new Set<string>());
+	useEffect(() => {
+		if (!statusStream) return;
+		const { statuses } = statusStream;
+		setSimulationsStatusData(prev => prev?.map(data => withStatus(data, statuses[data.jobId])));
+		Object.values(statuses)
+			.filter(
+				status =>
+					status.jobState &&
+					FINAL_STATES.has(status.jobState) &&
+					!fetchedFinal.current.has(status.jobId) &&
+					simulationInfo.some(info => info.jobId === status.jobId)
+			)
+			.forEach(status => {
+				fetchedFinal.current.add(status.jobId);
+				updateSpecificSimulationData(status.jobId);
+			});
+	}, [statusStream, simulationInfo, setSimulationsStatusData, updateSpecificSimulationData]);
+
 	const simulationDataInterval = useMemo(() => {
-		if (!isBackendAlive) return undefined;
+		// pushed by the server; polled only when the stream cannot be opened
+		if (!isBackendAlive || statusStream?.live) return undefined;
 
 		const allSettled = simulationsStatusData?.every(
 			s =>
@@ -126,7 +179,7 @@ const SimulationsGridHelpers = (
 		if (allSettled) return 10000;
 
 		return 1500;
-	}, [isBackendAlive, simulationsStatusData]);
+	}, [isBackendAlive, simulationsStatusData, statusStream?.live]);
 
 	const handleLoadResults = async (
 		taskId: string | null,
@@ -134,7 +187,10 @@ const SimulationsGridHelpers = (
 	) => {
 		if (taskId === null) return goToResults?.call(null);
 
-		if (currentJobStatusData[StatusState.COMPLETED](simulation)) {
+		if (
+			currentJobStatusData[StatusState.COMPLETED](simulation) ||
+			partialRevision(simulation as JobStatusData) !== undefined
+		) {
 			const fullData = isFullSimulationData(simulation)
 				? (simulation as unknown as FullSimulationData)
 				: await getFullSimulationData(simulation, controller.signal);
@@ -294,4 +350,7 @@ const SimulationsGridHelpers = (
 	};
 };
 
+// a finished run opens its results once: the grids see its final status again on every remount and stream reconnect
+const runFinishShown = new Set<string>();
+
 export default SimulationsGridHelpers;
diff --git a/src/WrapperApp/components/Simulation/SimulationsGrid/SimulationsGridTypes.ts b/src/WrapperApp/components/Simulation/SimulationsGrid/SimulationsGridTypes.ts
index 2510b7d69..45a35fe88 100644
--- a/src/WrapperApp/components/Simulation/SimulationsGrid/SimulationsGridTypes.ts
+++ b/src/WrapperApp/components/Simulation/SimulationsGrid/SimulationsGridTypes.ts
@@ -1,4 +1,5 @@
 import { ResultsSimulationDataWithSource } from '../../../../services/StoreService';
+import { SimulationStatusStream } from '../../../../services/useSimulationStatusStream';
 import { YaptideEditor } from '../../../../ThreeEditor/js/YaptideEditor';
 import {
 	JobInputs,
@@ -56,6 +57,7 @@ export interface SimulationHandlers {
 	) => Promise<FullSimulationData | undefined>;
 	getHelloWorld: (...args: RequestParam) => Promise<unknown>;
 	cancelJob: (info: SimulationInfo, signal?: AbortSignal) => Promise<unknown>;
+	statusStream?: SimulationStatusStream;
 }
 
 export interface SimulationState {
diff --git a/src/WrapperApp/components/Simulation/SimulationsGrid/hooks/useUpdateCurrentSimulationEffect.ts b/src/WrapperApp/components/Simulation/SimulationsGrid/hooks/useUpdateCurrentSimulationEffect.ts
index 9600bac93..e97b4c8ba 100644
--- a/src/WrapperApp/components/Simulation/SimulationsGrid/hooks/useUpdateCurrentSimulationEffect.ts
+++ b/src/WrapperApp/components/Simulation/SimulationsGrid/hooks/useUpdateCurrentSimulationEffect.ts
@@ -13,28 +13,45 @@ export const useUpdateCurrentSimulationEffect = (
 	const { simulationsStatusData, yaptideEditor } = state;
 
 	useEffect(() => {
+		// every poll starts a new run; a slower older run must not overwrite what a newer one set
+		let stale = false;
 		const updateCurrentSimulation = async () => {
 			if (shouldConnect && yaptideEditor) {
 				const hash = yaptideEditor.toSerialized().hash;
-				const currentStatus = simulationsStatusData?.find(async s => {
-					if (currentJobStatusData[StatusState.COMPLETED](s)) {
-						const jobInputs = await getJobInputs(s, controller.signal);
+				// find() with an async callback always took the first simulation, a promise is truthy
+				let currentStatus;
 
-						return jobInputs?.input.inputJson?.hash === hash;
-					}
+				for (const s of simulationsStatusData ?? []) {
+					if (!currentJobStatusData[StatusState.COMPLETED](s)) continue;
+					// one failed request must not stop the search
+					const jobInputs = await getJobInputs(s, controller.signal).catch(
+						() => undefined
+					);
+
+					if (jobInputs?.input.inputJson?.hash === hash) {
+						currentStatus = s;
 
-					return false;
-				});
+						break;
+					}
+				}
 
 				const currentSimulation = currentStatus
-					? await getFullSimulationData(currentStatus, controller.signal)
+					? await getFullSimulationData(currentStatus, controller.signal).catch(
+							() => undefined
+						)
 					: undefined;
 
+				if (stale) return;
+
 				if (currentSimulation) yaptideEditor.setResults(currentSimulation);
 				else yaptideEditor.setResults(null);
 			}
 		};
 		updateCurrentSimulation();
+
+		return () => {
+			stale = true;
+		};
 	}, [
 		simulationsStatusData,
 		yaptideEditor,
diff --git a/src/libs/converter b/src/libs/converter
index 10223d4b9..47791d417 160000
--- a/src/libs/converter
+++ b/src/libs/converter
@@ -1 +1 @@
-Subproject commit 10223d4b9916650b8c6b9b6a5f9d7d9ecefe6106
+Subproject commit 47791d41729f01e8241b9f2a28e7c98b99dcaca8
diff --git a/src/services/CacheMap.ts b/src/services/CacheMap.ts
index e66e71eb1..72b4e1f7e 100644
--- a/src/services/CacheMap.ts
+++ b/src/services/CacheMap.ts
@@ -35,11 +35,21 @@ export default class CacheMap<T extends {}> {
 		key: string,
 		beforeWriteCallback?: (key: string, value: T) => void
 	) {
-		const cachePromise = new Promise<T>(async resolve => fn(resolve)).then(data => {
-			this.set(key, data, beforeWriteCallback);
-
-			return data;
-		});
+		const cachePromise: Promise<T> = new Promise<T>((resolve, reject) => {
+			// a failed fetch must reject, not leave every caller waiting on this cache entry forever
+			Promise.resolve(fn(resolve)).catch(reject);
+		}).then(
+			data => {
+				this.set(key, data, beforeWriteCallback);
+
+				return data;
+			},
+			error => {
+				if (this.data.get(key) === cachePromise) this.delete(key);
+
+				throw error;
+			}
+		);
 
 		this.set(key, cachePromise);
 
diff --git a/src/services/LoaderService.tsx b/src/services/LoaderService.tsx
index 60ad75474..d2af34661 100644
--- a/src/services/LoaderService.tsx
+++ b/src/services/LoaderService.tsx
@@ -21,15 +21,10 @@ const isEditorJson = (data: unknown): data is EditorJson => {
 };
 
 export const isFullSimulationData = (data: unknown): data is FullSimulationData => {
-	return hasFields(
-		data,
-		'input',
-		'estimators',
-		'jobState',
-		'jobId',
-		'jobTasksStatus',
-		'metadata',
-		'startTime'
+	return (
+		hasFields(data, 'input', 'estimators', 'jobState', 'jobId', 'metadata', 'startTime') &&
+		// saved before the status carried totals instead of the task list, or after
+		(hasFields(data, 'jobTasksStatus') || hasFields(data, 'jobTasksSummary'))
 	);
 };
 
diff --git a/src/services/RemoteWorkerSimulationContextProvider.tsx b/src/services/RemoteWorkerSimulationContextProvider.tsx
index e291ab846..81f9c2a60 100644
--- a/src/services/RemoteWorkerSimulationContextProvider.tsx
+++ b/src/services/RemoteWorkerSimulationContextProvider.tsx
@@ -1,15 +1,23 @@
-import { useEffect, useRef } from 'react';
+import { useEffect, useMemo, useRef } from 'react';
 
+import { useConfig } from '../config/ConfigService';
 import { SimulationContext } from '../types/SimulationService';
 import { useAuth } from './AuthService';
 import { createGenericContext, GenericContextProviderProps } from './GenericContext';
 import RemoteWorkerSimulationService from './RemoteWorkerSimulationService';
+import { useSimulationStatusStream } from './useSimulationStatusStream';
 
 const [useRemoteWorkerSimulation, InnerRemoteWorkerSimulationContextProvider] =
 	createGenericContext<SimulationContext>();
 
 function RemoteWorkerSimulationContextProvider({ children }: GenericContextProviderProps) {
-	const { authKy } = useAuth();
+	const { authKy, user } = useAuth();
+	const { demoMode } = useConfig();
+	const statusStream = useSimulationStatusStream(
+		// another user logging in gets a stream of their own
+		demoMode ? undefined : user?.username
+	);
+
 	const simulationServiceRef = useRef<RemoteWorkerSimulationService>(
 		new RemoteWorkerSimulationService(authKy)
 	);
@@ -18,42 +26,29 @@ function RemoteWorkerSimulationContextProvider({ children }: GenericContextProvi
 		simulationServiceRef.current.authKy = authKy;
 	}, [authKy]);
 
+	// bound once: the stream re-renders this provider on every pushed status, and new functions would make every
+	// consumer fetch again
+	const handlers = useMemo(() => {
+		const service = simulationServiceRef.current;
+
+		return {
+			postJob: service.postJob.bind(service),
+			cancelJob: service.cancelJob.bind(service),
+			getHelloWorld: service.helloWorld.bind(service),
+			getJobStatus: service.getJobStatus.bind(service),
+			getPageContents: service.getPageContents.bind(service),
+			getPageStatus: service.getPageStatus.bind(service),
+			getJobInputs: service.getJobInputs.bind(service),
+			getJobResults: service.getJobResults.bind(service),
+			getEstimatorsPages: service.getEstimatorsPages.bind(service),
+			getJobLogs: service.getJobLogs.bind(service),
+			getFullSimulationData: service.getFullSimulationData.bind(service)
+		};
+	}, []);
+	const value = useMemo(() => ({ ...handlers, statusStream }), [handlers, statusStream]);
+
 	return (
-		<InnerRemoteWorkerSimulationContextProvider
-			value={{
-				// `bind()` is required, otherwise `this` is undefined when calling the function
-				postJob: simulationServiceRef.current.postJob.bind(simulationServiceRef.current),
-				cancelJob: simulationServiceRef.current.cancelJob.bind(
-					simulationServiceRef.current
-				),
-				getHelloWorld: simulationServiceRef.current.helloWorld.bind(
-					simulationServiceRef.current
-				),
-				getJobStatus: simulationServiceRef.current.getJobStatus.bind(
-					simulationServiceRef.current
-				),
-				getPageContents: simulationServiceRef.current.getPageContents.bind(
-					simulationServiceRef.current
-				),
-				getPageStatus: simulationServiceRef.current.getPageStatus.bind(
-					simulationServiceRef.current
-				),
-				getJobInputs: simulationServiceRef.current.getJobInputs.bind(
-					simulationServiceRef.current
-				),
-				getJobResults: simulationServiceRef.current.getJobResults.bind(
-					simulationServiceRef.current
-				),
-				getEstimatorsPages: simulationServiceRef.current.getEstimatorsPages.bind(
-					simulationServiceRef.current
-				),
-				getJobLogs: simulationServiceRef.current.getJobLogs.bind(
-					simulationServiceRef.current
-				),
-				getFullSimulationData: simulationServiceRef.current.getFullSimulationData.bind(
-					simulationServiceRef.current
-				)
-			}}>
+		<InnerRemoteWorkerSimulationContextProvider value={value}>
 			{children}
 		</InnerRemoteWorkerSimulationContextProvider>
 	);
diff --git a/src/services/RemoteWorkerSimulationService.ts b/src/services/RemoteWorkerSimulationService.ts
index 14deb9f6f..9b1bd99ee 100644
--- a/src/services/RemoteWorkerSimulationService.ts
+++ b/src/services/RemoteWorkerSimulationService.ts
@@ -50,9 +50,12 @@ import {
 } from '../types/ResponseTypes';
 import { FullSimulationData, SimulationService } from '../types/SimulationService';
 import { camelToSnakeCase } from '../util/Notation/Notation';
+import { partialRevision } from '../util/partialResults';
+import { taskTotals } from '../util/taskTotals';
 import { ValidateShape } from '../util/Types';
 import { SimulationSourceType } from '../WrapperApp/components/Simulation/RunSimulationForm';
 import CacheMap from './CacheMap';
+import { resolveStoredPages } from './storedPages';
 
 const CACHEABLE_STATUSES = new Set([
 	StatusState.FAILED,
@@ -62,35 +65,15 @@ const CACHEABLE_STATUSES = new Set([
 
 const VALID_STATUSES = new Set(ValidStatusStates);
 
-//TODO: fix backend responses and remove this function
-//TODO: (2025) Find out what does the above mean & fix
+// a completed simulation is cached once every task has ended
 function validStatusToCache(data: JobStatusCompleted | JobStatusFailed) {
 	if (data.jobState === StatusState.FAILED) {
 		return true;
 	}
 
-	return data.jobTasksStatus.every(task => {
-		if (task.taskState && task.taskState === StatusState.FAILED) {
-			return true;
-		}
-
-		if (task.taskState && task.taskState === StatusState.COMPLETED) {
-			if (!task.startTime || !task.endTime)
-				console.warn('There are missing times in COMPLETED task:', task);
-
-			if (task.requestedPrimaries !== task.simulatedPrimaries) {
-				console.warn(
-					'Requested primaries and simulated primaries are not equal in COMPLETED task:',
-					task
-				);
-				task.simulatedPrimaries = task.requestedPrimaries;
-			}
-
-			return true;
-		}
+	const totals = taskTotals(data);
 
-		return false;
-	});
+	return totals !== undefined && totals.finishedTasks === totals.ntasks;
 }
 
 /**
@@ -113,25 +96,27 @@ export function getEndpointFromSimulationInfo(info: SimulationInfo) {
 }
 
 /**
- * Rebuilds the references between estimators and their corresponding scoring manager outputs.
- * Each estimator is linked to an output in the scoring manager JSON by matching array indices.
- * The scoringManagerJSON.outputs array length should match the number of estimators - if there are
- * fewer outputs than estimators, the extra estimators will have undefined scoringOutputJsonRef.
- * If there are more outputs than estimators, the extra outputs will be ignored.
+ * Links each estimator to the scoring manager output it was scored by: by the output uuid the backend sends
+ * with the results, or by the output name (which the backend gives the estimator) for results without it.
+ * An estimator no output matches keeps no reference, and the mismatch is reported.
  *
  * @param estimators - Array of estimators that need scoring manager output references rebuilt
- * @param scoringManagerJSON - The scoring manager JSON containing output definitions. The outputs array
- *                            should ideally have the same length as the estimators array to ensure
- *                            all estimators get valid output references.
+ * @param scoringManagerJSON - The scoring manager JSON containing output definitions
  * @returns The estimators array with updated scoring output references for each estimator
  */
 function recreateRefToScoringManagerOutputs(
 	estimators: Estimator[],
 	scoringManagerJSON: ScoringManagerJSON
 ): Estimator[] {
-	// Iterate through each estimator and set the scoringOutputJsonRef to the corresponding output in scoringManagerJSON
-	estimators.forEach((estimator, index) => {
-		estimator.scoringOutputJsonRef = scoringManagerJSON.outputs[index];
+	estimators.forEach(estimator => {
+		estimator.scoringOutputJsonRef = scoringManagerJSON.outputs.find(output =>
+			estimator.outputUuid
+				? output.uuid === estimator.outputUuid
+				: output.name === estimator.name
+		);
+
+		if (!estimator.scoringOutputJsonRef)
+			console.error(`Estimator ${estimator.name} matches no output of the simulation`);
 	});
 
 	return estimators;
@@ -162,11 +147,9 @@ function recreateRefToFilters(estimators: Estimator[], FiltersJSON: FilterJSON[]
 
 /**
  * Recreates references in simulation results by linking estimator data with scoring manager outputs and filters
- * from the editor JSON. This function expects specific array length relationships to work properly:
+ * from the editor JSON:
  *
- * 1. The scoringManager.outputs array length should match the number of estimators, otherwise:
- *    - If fewer outputs than estimators: excess estimators will have undefined scoringOutputJsonRef
- *    - If more outputs than estimators: extra outputs are ignored
+ * 1. Each estimator is linked to its scoring manager output by the output uuid (or name)
  * 2. Within each estimator, the number of pages should match the number of quantities in the
  *    corresponding scoring manager output for proper filter assignment
  *
@@ -325,7 +308,8 @@ export default class RemoteWorkerSimulationService implements SimulationService
 		return this.authKy
 			.get(`jobs/${runType}`, {
 				signal,
-				searchParams: camelToSnakeCase({ jobId })
+				// totals are enough for the simulations list, the task list would be ~70 kB for 500 tasks
+				searchParams: camelToSnakeCase({ jobId, tasks: false })
 			})
 			.json<ResponseGetJobStatus>()
 			.then(response => {
@@ -401,6 +385,11 @@ export default class RemoteWorkerSimulationService implements SimulationService
 					})
 					.json<ResponseGetJobResults>();
 
+				await Promise.all(
+					response.estimators.map(async estimator => {
+						estimator.pages = await resolveStoredPages(estimator.pages, signal);
+					})
+				);
 				updateEstimators(response.estimators);
 
 				const jobInputs = await this.getJobInputs(info, signal, cache);
@@ -448,7 +437,7 @@ export default class RemoteWorkerSimulationService implements SimulationService
 
 	async getEstimatorsPages(...args: RequestGetJobResult): Promise<JobResults | undefined> {
 		const [info, signal, cache = true, beforeCacheWrite] = args;
-		const { jobId, estimatorName, pageNumbers } = info;
+		const { jobId, estimatorName, pageNumbers, revision } = info;
 
 		const searchParams = new URLSearchParams({
 			job_id: jobId,
@@ -456,7 +445,7 @@ export default class RemoteWorkerSimulationService implements SimulationService
 			page_numbers: this.preparePageNumbers(pageNumbers)
 		});
 
-		const cacheKey = `${jobId}-${estimatorName}-${pageNumbers.join(',')}`;
+		const cacheKey = `${jobId}-${estimatorName}-${pageNumbers.join(',')}${revision === undefined ? '' : `@${revision}`}`;
 
 		if (cache && this.resultsCache.has(cacheKey)) {
 			const data: Promise<JobResults> | JobResults | undefined =
@@ -481,6 +470,14 @@ export default class RemoteWorkerSimulationService implements SimulationService
 			}
 		}
 
+		// pages of older partial results of the simulation are never read again
+		for (const key of Array.from(this.resultsCache.data.keys())) {
+			const partial = key.match(/@(\d+)$/);
+
+			if (partial && key.startsWith(`${jobId}-`) && Number(partial[1]) !== revision)
+				this.resultsCache.delete(key);
+		}
+
 		const cachePromise = this.resultsCache.createPromise(
 			async resolve => {
 				const response = await this.authKy
@@ -493,7 +490,7 @@ export default class RemoteWorkerSimulationService implements SimulationService
 				const estimator: Estimator[] = [
 					{
 						name: estimatorName,
-						pages: response.pages
+						pages: await resolveStoredPages(response.pages, signal)
 					}
 				];
 
@@ -594,7 +591,11 @@ export default class RemoteWorkerSimulationService implements SimulationService
 		inputs: JobInputs | undefined,
 		givenEstimatorName?: string
 	) {
-		if (!givenEstimatorName && jobStatus.jobState === StatusState.COMPLETED) {
+		if (
+			!givenEstimatorName &&
+			(jobStatus.jobState === StatusState.COMPLETED ||
+				partialRevision(jobStatus) !== undefined)
+		) {
 			if (inputs && !inputs.input.estimatorsItems) {
 				const estimators = await this.getCurrentEstimators(jobStatus.jobId);
 
@@ -645,7 +646,8 @@ export default class RemoteWorkerSimulationService implements SimulationService
 						{
 							jobId: jobStatus.jobId,
 							estimatorName: firstEstimatorName,
-							pageNumbers: pageDimension.pageNums
+							pageNumbers: pageDimension.pageNums,
+							revision: partialRevision(jobStatus)
 						},
 						signal,
 						cache
diff --git a/src/services/__tests__/RemoteWorkerSimulationService.test.ts b/src/services/__tests__/RemoteWorkerSimulationService.test.ts
new file mode 100644
index 000000000..38b364272
--- /dev/null
+++ b/src/services/__tests__/RemoteWorkerSimulationService.test.ts
@@ -0,0 +1,82 @@
+import { KyInstance } from 'ky';
+
+import { EditorJson } from '../../ThreeEditor/js/EditorJson';
+import RemoteWorkerSimulationService, {
+	recreateRefsInResults
+} from '../RemoteWorkerSimulationService';
+
+jest.mock('ky', () => ({ get: jest.fn() }));
+
+describe('pages of partial results', () => {
+	test('a newer revision drops the pages of the older ones of the same simulation', async () => {
+		const ky = {
+			get: (url: string) => ({
+				json: async () => (url === 'inputs' ? { input: {} } : { pages: [], message: '' })
+			})
+		} as unknown as KyInstance;
+		const service = new RemoteWorkerSimulationService(ky);
+		const load = (jobId: string, revision?: number) =>
+			service.getEstimatorsPages({
+				jobId,
+				estimatorName: 'dose',
+				pageNumbers: [0],
+				revision
+			});
+
+		await load('job', 300);
+		await load('other', 300);
+		await load('job', 600);
+
+		expect(Array.from(service.resultsCache.data.keys())).toEqual([
+			'other-dose-0@300',
+			'job-dose-0@600'
+		]);
+
+		await load('job');
+
+		expect(Array.from(service.resultsCache.data.keys())).toEqual([
+			'other-dose-0@300',
+			'job-dose-0'
+		]);
+	});
+});
+
+describe('results of the editor outputs', () => {
+	const output = (uuid: string, name: string) => ({ uuid, name, quantities: [] });
+	const inputJson = {
+		scoringManager: {
+			outputs: [output('a', 'dose'), output('b', 'dose'), output('c', 'fluence')],
+			filters: []
+		}
+	} as unknown as EditorJson;
+
+	test('estimators in any order get the outputs they were scored by', () => {
+		const estimators = recreateRefsInResults(inputJson, [
+			{ name: 'fluence', outputUuid: 'c', pages: [] },
+			{ name: 'dose', outputUuid: 'b', pages: [] },
+			{ name: 'dose', outputUuid: 'a', pages: [] }
+		]);
+
+		expect(estimators.map(estimator => estimator.scoringOutputJsonRef?.uuid)).toEqual([
+			'c',
+			'b',
+			'a'
+		]);
+	});
+
+	test('results without output uuids are matched by name, and a mismatch is reported', () => {
+		const error = jest.spyOn(console, 'error').mockImplementation(() => {});
+
+		const estimators = recreateRefsInResults(inputJson, [
+			{ name: 'other', pages: [] },
+			{ name: 'fluence', pages: [] }
+		]);
+
+		expect(estimators.map(estimator => estimator.scoringOutputJsonRef?.uuid)).toEqual([
+			undefined,
+			'c'
+		]);
+		expect(error).toHaveBeenCalledWith('Estimator other matches no output of the simulation');
+		error.mockRestore();
+	});
+});
diff --git a/src/services/storedPages.test.ts b/src/services/storedPages.test.ts
new file mode 100644
index 000000000..d13014935
--- /dev/null
+++ b/src/services/storedPages.test.ts
@@ -0,0 +1,30 @@
+import ky from 'ky';
+
+import { Page } from '../JsRoot/GraphData';
+import { resolveStoredPages } from './storedPages';
+
+jest.mock('ky', () => ({ get: jest.fn() }));
+
+describe('resolveStoredPages', () => {
+	it('fetches pages kept in storage and converts their keys, keeping pages sent inline', async () => {
+		(ky.get as jest.Mock).mockReturnValue({
+			json: () =>
+				Promise.resolve({ metadata: { page_number: 1 }, axis_dim1: { values: [1] } })
+		});
+		const inline = { dimensions: 0, metadata: { pageNumber: 0 } } as unknown as Page;
+		const stored = {
+			pageNumber: 1,
+			url: 'https://storage/p1',
+			format: 'page-json-gzip-v1'
+		} as unknown as Page;
+
+		const pages = await resolveStoredPages([inline, stored]);
+
+		expect(pages[0]).toBe(inline);
+		expect(pages[1]).toEqual({ metadata: { pageNumber: 1 }, axisDim1: { values: [1] } });
+		expect(ky.get).toHaveBeenCalledWith(
+			'https://storage/p1',
+			expect.objectContaining({ retry: 2 })
+		);
+	});
+});
diff --git a/src/services/storedPages.ts b/src/services/storedPages.ts
new file mode 100644
index 000000000..113329ab6
--- /dev/null
+++ b/src/services/storedPages.ts
@@ -0,0 +1,31 @@
+import ky from 'ky';
+
+import { Page } from '../JsRoot/GraphData';
+import { snakeToCamelCase } from '../util/Notation/Notation';
+
+/**
+ * A result page kept in object storage: the backend sends a signed link instead of the page.
+ */
+type StoredPage = { pageNumber: number; url: string; format: string };
+
+const isStoredPage = (page: unknown): page is StoredPage =>
+	typeof (page as StoredPage | undefined)?.url === 'string';
+
+/**
+ * Replaces pages kept in object storage with the pages themselves, fetched in parallel from their signed links.
+ * The page JSON goes through the same snake_case to camelCase conversion as the backend's API responses.
+ */
+export function resolveStoredPages(pages: Page[], signal?: AbortSignal): Promise<Page[]> {
+	return Promise.all(
+		pages.map(page =>
+			isStoredPage(page)
+				? ky
+						// no timeout: requests beyond the browser's ~6 connections wait in its queue, and a large page
+						// on a slow link takes long; the abort signal still stops them
+						.get(page.url, { signal, retry: 2, timeout: false })
+						.json<object>()
+						.then(json => snakeToCamelCase(json, true) as unknown as Page)
+				: page
+		)
+	);
+}
diff --git a/src/services/useSimulationStatusStream.test.ts b/src/services/useSimulationStatusStream.test.ts
new file mode 100644
index 000000000..6530a2714
--- /dev/null
+++ b/src/services/useSimulationStatusStream.test.ts
@@ -0,0 +1,108 @@
+import { act, renderHook } from '@testing-library/react';
+
+import { StatusState } from '../types/ResponseTypes';
+import { StreamedStatus, useSimulationStatusStream, withStatus } from './useSimulationStatusStream';
+
+jest.mock('../config/ConfigService', () => ({
+	useConfig: () => ({ backendUrl: 'http://backend' })
+}));
+
+describe('withStatus', () => {
+	const running: StreamedStatus & { title: string } = {
+		jobId: 'job',
+		title: 'shown',
+		jobState: StatusState.RUNNING,
+		partialResults: { simulatedPrimaries: 300, time: '2026-10-17T12:00:00+00:00' }
+	};
+
+	test('final results replace the partial ones, the rest of the shown data stays', () => {
+		const completed = withStatus(running, { jobId: 'job', jobState: StatusState.COMPLETED });
+
+		expect(completed).toEqual({
+			jobId: 'job',
+			title: 'shown',
+			jobState: StatusState.COMPLETED,
+			partialResults: undefined
+		});
+	});
+
+	test('a submitted simulation no longer shows the busy cluster it waited for, nor its notice', () => {
+		const waiting: StreamedStatus = {
+			jobId: 'job',
+			jobState: StatusState.PENDING,
+			clusterBusyUntil: '2026-10-18T12:00:00+00:00',
+			clusterNotice: 'Access to the login nodes has been temporarily restricted'
+		};
+		const submitted = withStatus(waiting, { jobId: 'job', jobState: StatusState.RUNNING });
+
+		expect(submitted.clusterBusyUntil).toBeUndefined();
+		expect(submitted.clusterNotice).toBeUndefined();
+	});
+
+	test('a final state is kept: a status pushed before it is older', () => {
+		const canceled: typeof running = { ...running, jobState: StatusState.CANCELED };
+
+		expect(withStatus(canceled, { jobId: 'job', jobState: StatusState.RUNNING })).toBe(
+			canceled
+		);
+	});
+});
+
+describe('useSimulationStatusStream', () => {
+	const sources: FakeEventSource[] = [];
+
+	class FakeEventSource {
+		static CLOSED = 2;
+
+		readyState = 0;
+
+		onopen?: () => void;
+
+		onmessage?: (event: { data: string }) => void;
+
+		onerror?: () => void;
+
+		constructor() {
+			sources.push(this);
+		}
+
+		close() {
+			this.readyState = FakeEventSource.CLOSED;
+		}
+
+		refuse() {
+			this.close();
+			this.onerror?.();
+		}
+	}
+
+	beforeEach(() => {
+		jest.useFakeTimers();
+		sources.length = 0;
+		Object.assign(global, { EventSource: FakeEventSource });
+	});
+
+	afterEach(() => jest.useRealTimers());
+
+	test('polls after three refusals without the pushed statuses, and goes live again once the stream opens', () => {
+		const { result } = renderHook(() => useSimulationStatusStream('user'));
+		act(() => {
+			sources[0].onopen?.();
+			sources[0].onmessage?.({ data: '{"job_id": "job", "job_state": "RUNNING"}' });
+		});
+		expect(result.current.statuses.job.jobState).toBe(StatusState.RUNNING);
+
+		for (const wait of [1000, 5000, 15000]) {
+			act(() => sources[sources.length - 1].refuse());
+			act(() => jest.advanceTimersByTime(wait));
+		}
+
+		act(() => sources[sources.length - 1].refuse());
+		expect(result.current.live).toBe(false);
+		expect(result.current.statuses).toEqual({});
+
+		act(() => jest.advanceTimersByTime(60000));
+		act(() => sources[sources.length - 1].onopen?.());
+		expect(result.current.live).toBe(true);
+	});
+});
diff --git a/src/services/useSimulationStatusStream.ts b/src/services/useSimulationStatusStream.ts
new file mode 100644
index 000000000..486855bc2
--- /dev/null
+++ b/src/services/useSimulationStatusStream.ts
@@ -0,0 +1,110 @@
+import { useEffect, useMemo, useState } from 'react';
+
+import { useConfig } from '../config/ConfigService';
+import { JobUnknownStatus, StatusState } from '../types/ResponseTypes';
+import { snakeToCamelCase } from '../util/Notation/Notation';
+
+export type StreamedStatus = JobUnknownStatus & { jobId: string };
+
+export interface SimulationStatusStream {
+	// the latest status pushed for each simulation, by job id
+	statuses: Record<string, StreamedStatus>;
+	// false once the stream was refused too often: statuses are polled instead
+	live: boolean;
+	// counts the (re)openings; a simulation that finished while the stream was closed is not sent again
+	opened: number;
+}
+
+const FINAL_STATES = new Set([StatusState.COMPLETED, StatusState.FAILED, StatusState.CANCELED]);
+
+/**
+ * The pushed status in place of the held one; final results come without partial results, a submitted simulation
+ * without the busy cluster it waited for. A final state never
+ * changes, so a status pushed before it is older and is not applied.
+ */
+export function withStatus<T extends JobUnknownStatus>(
+	data: T,
+	status: StreamedStatus | undefined
+): T {
+	if (!status || (data.jobState && FINAL_STATES.has(data.jobState))) return data;
+
+	return {
+		...data,
+		partialResults: undefined,
+		clusterBusyUntil: undefined,
+		clusterNotice: undefined,
+		...status
+	};
+}
+
+// waits before opening a refused stream again (e.g. an expired token, refreshed meanwhile); then polling takes over,
+// and the stream is still tried now and then, so a restarted server ends the polling
+const REOPEN_MS = [1000, 5000, 15000];
+const RETRY_MS = 60000;
+
+/**
+ * One stream per logged in session with the status of all the user's unfinished simulations (server-sent events),
+ * sent when one is submitted, its state or partial results change, or its tasks report progress.
+ */
+export function useSimulationStatusStream(username: string | undefined): SimulationStatusStream {
+	const { backendUrl } = useConfig();
+	const [statuses, setStatuses] = useState<Record<string, StreamedStatus>>({});
+	const [live, setLive] = useState(true);
+	const [opened, setOpened] = useState(0);
+
+	useEffect(() => {
+		setStatuses({});
+		setLive(true);
+
+		if (username === undefined) return;
+		let source: EventSource | undefined;
+		let reopen: ReturnType<typeof setTimeout> | undefined;
+		let refusals = 0;
+
+		const open = () => {
+			source = new EventSource(`${backendUrl}/events/simulations`, {
+				withCredentials: true
+			});
+
+			source.onopen = () => {
+				refusals = 0;
+				setLive(true);
+				setOpened(count => count + 1);
+			};
+
+			source.onmessage = event => {
+				const status = snakeToCamelCase(
+					JSON.parse(event.data) as object,
+					true
+				) as StreamedStatus;
+				setStatuses(prev => ({ ...prev, [status.jobId]: status }));
+			};
+
+			source.onerror = () => {
+				// the browser reconnects a dropped stream itself, a refused one stays closed
+				if (source?.readyState !== EventSource.CLOSED) return;
+
+				if (refusals === REOPEN_MS.length) {
+					setLive(false);
+					// polled from now on: statuses pushed before would hide the polled ones
+					setStatuses({});
+				}
+
+				reopen = setTimeout(open, REOPEN_MS[refusals++] ?? RETRY_MS);
+			};
+		};
+		open();
+
+		return () => {
+			clearTimeout(reopen);
+			source?.close();
+		};
+	}, [username, backendUrl]);
+
+	const enabled = username !== undefined;
+
+	return useMemo(
+		() => ({ statuses, live: enabled && live, opened }),
+		[statuses, enabled, live, opened]
+	);
+}
diff --git a/src/types/RequestTypes.ts b/src/types/RequestTypes.ts
index 186c48345..4637a065f 100644
--- a/src/types/RequestTypes.ts
+++ b/src/types/RequestTypes.ts
@@ -149,7 +149,8 @@ export type RequestGetJobResults = Flatten<
 
 export type RequestGetJobResult = Flatten<
 	[
-		[{ jobId: string; estimatorName: string; pageNumbers: number[] }],
+		// revision: the primaries partial results cover, so each new partial is fetched again
+		[{ jobId: string; estimatorName: string; pageNumbers: number[]; revision?: number }],
 		RequestParam,
 		CachedDataParams<JobResults>
 	]
diff --git a/src/types/ResponseTypes.ts b/src/types/ResponseTypes.ts
index 996f510e1..cbaebc809 100644
--- a/src/types/ResponseTypes.ts
+++ b/src/types/ResponseTypes.ts
@@ -202,43 +202,71 @@ export type TaskUnknownStatus = {
 
 /* ------------------------------------ */
 // Types defining all possible types of job status data
+/**
+ * Totals over the tasks of a simulation, sent by the server instead of the full task list.
+ */
+export type JobTasksSummary = {
+	ntasks: number;
+	// keys go through the snake_case to camelCase conversion; single-word task states are unchanged
+	taskStates: Record<string, number>;
+	requestedPrimaries: number;
+	simulatedPrimaries: number;
+};
+
+/**
+ * Results stored while the simulation runs, covering only the primaries simulated so far.
+ */
+export type PartialResults = {
+	simulatedPrimaries: number;
+	// ISO time with offset
+	time: string;
+};
+
 type JobStatusType<T extends StatusState, U extends Object> = TypeIdentifiedByKey<
 	'jobState',
 	T,
-	U & YaptideResponse
+	U &
+		YaptideResponse & {
+			jobTasksSummary?: JobTasksSummary;
+			partialResults?: PartialResults;
+			// ISO time with offset: the HPC cluster did not answer, the server tries to submit again then
+			clusterBusyUntil?: string;
+			// what the busy cluster's admins said when its login node closed the connection
+			clusterNotice?: string;
+		}
 >;
 
 export type JobStatusCompleted = JobStatusType<
 	StatusState.COMPLETED,
 	{
-		jobTasksStatus: Array<TaskUnknownStatus>;
+		jobTasksStatus?: Array<TaskUnknownStatus>;
 	}
 >;
 
 export type JobStatusCanceled = JobStatusType<
 	StatusState.CANCELED,
 	{
-		jobTasksStatus: Array<TaskUnknownStatus>;
+		jobTasksStatus?: Array<TaskUnknownStatus>;
 	}
 >;
 
 export type JobStatusMergingQueued = JobStatusType<
 	StatusState.MERGING_QUEUED,
 	{
-		jobTasksStatus: Array<TaskUnknownStatus>;
+		jobTasksStatus?: Array<TaskUnknownStatus>;
 	}
 >;
 
 export type JobStatusMergingRunning = JobStatusType<
 	StatusState.MERGING_RUNNING,
 	{
-		jobTasksStatus: Array<TaskUnknownStatus>;
+		jobTasksStatus?: Array<TaskUnknownStatus>;
 	}
 >;
 
 export type JobStatusRunning = JobStatusType<
 	StatusState.RUNNING,
-	{ jobTasksStatus: Array<TaskUnknownStatus> }
+	{ jobTasksStatus?: Array<TaskUnknownStatus> }
 >;
 
 export type JobStatusPending = JobStatusType<StatusState.PENDING, {}>;
@@ -270,6 +298,10 @@ export type JobUnknownStatus = {
 		| StatusState.CANCELED;
 	message?: string;
 	jobTasksStatus?: Array<TaskUnknownStatus>;
+	jobTasksSummary?: JobTasksSummary;
+	partialResults?: PartialResults;
+	clusterBusyUntil?: string;
+	clusterNotice?: string;
 };
 
 type ResponseJobRequestFailure = Omit<
diff --git a/src/types/SimulationService.ts b/src/types/SimulationService.ts
index bd65e8bb1..60b8ac105 100644
--- a/src/types/SimulationService.ts
+++ b/src/types/SimulationService.ts
@@ -1,3 +1,4 @@
+import { SimulationStatusStream } from '../services/useSimulationStatusStream';
 import {
 	JobInputs,
 	JobLogs,
@@ -34,6 +35,8 @@ export interface SimulationContext {
 		cache?: boolean,
 		givenEstimatorName?: string
 	) => Promise<FullSimulationData | undefined>;
+	// only the remote worker pushes the status of simulations
+	statusStream?: SimulationStatusStream;
 }
 
 export interface SimulationService {
diff --git a/src/util/clusterBusy.test.ts b/src/util/clusterBusy.test.ts
new file mode 100644
index 000000000..f1da2cb34
--- /dev/null
+++ b/src/util/clusterBusy.test.ts
@@ -0,0 +1,24 @@
+import { clusterBusyLabel } from './clusterBusy';
+
+describe('clusterBusyLabel', () => {
+	const until = '2026-10-18T12:05:00+00:00';
+
+	it('says when the busy cluster is tried again', () => {
+		const label = clusterBusyLabel(
+			{ clusterBusyUntil: until },
+			new Date('2026-10-18T12:00:00Z')
+		);
+
+		expect(label).toMatch(/^Cluster busy, trying again at \d\d:\d\d$/);
+	});
+
+	it('says it is tried now once that time passed', () => {
+		expect(
+			clusterBusyLabel({ clusterBusyUntil: until }, new Date('2026-10-18T12:06:00Z'))
+		).toBe('Cluster busy, trying again now');
+	});
+
+	it('says nothing for a simulation not waiting for its cluster', () => {
+		expect(clusterBusyLabel({})).toBeUndefined();
+	});
+});
diff --git a/src/util/clusterBusy.ts b/src/util/clusterBusy.ts
new file mode 100644
index 000000000..0ccf0eafb
--- /dev/null
+++ b/src/util/clusterBusy.ts
@@ -0,0 +1,17 @@
+import { format } from 'date-fns';
+
+/**
+ * What a simulation waiting for its HPC cluster tells the user, e.g. "Cluster busy, trying again at 14:05";
+ * undefined when it does not wait for one.
+ */
+export function clusterBusyLabel(
+	status: { clusterBusyUntil?: string },
+	now = new Date()
+): string | undefined {
+	if (!status.clusterBusyUntil) return undefined;
+	const until = new Date(status.clusterBusyUntil);
+
+	return until > now
+		? `Cluster busy, trying again at ${format(until, 'HH:mm')}`
+		: 'Cluster busy, trying again now';
+}
diff --git a/src/util/partialResults.test.ts b/src/util/partialResults.test.ts
new file mode 100644
index 000000000..5dcc905a6
--- /dev/null
+++ b/src/util/partialResults.test.ts
@@ -0,0 +1,29 @@
+import { StatusState } from '../types/ResponseTypes';
+import { partialResultsLabel, partialRevision } from './partialResults';
+
+const running = {
+	jobState: StatusState.RUNNING,
+	jobTasksSummary: {
+		ntasks: 2,
+		taskStates: { [StatusState.RUNNING]: 2 },
+		requestedPrimaries: 8000,
+		simulatedPrimaries: 3500
+	},
+	partialResults: { simulatedPrimaries: 3000, time: '2026-10-17T12:00:00+00:00' }
+};
+
+describe('partial results', () => {
+	it('says what the results cover and how old they are', () => {
+		expect(partialResultsLabel(running, new Date('2026-10-17T12:02:00Z'))).toBe(
+			'37% of primaries, 2 minutes ago'
+		);
+	});
+
+	it('treats the results of a completed simulation as final', () => {
+		const completed = { ...running, jobState: StatusState.COMPLETED };
+
+		expect(partialRevision(running)).toBe(3000);
+		expect(partialRevision(completed)).toBeUndefined();
+		expect(partialResultsLabel(completed)).toBeUndefined();
+	});
+});
diff --git a/src/util/partialResults.ts b/src/util/partialResults.ts
new file mode 100644
index 000000000..4434f2daa
--- /dev/null
+++ b/src/util/partialResults.ts
@@ -0,0 +1,36 @@
+import { formatDistance } from 'date-fns';
+
+import { JobTasksSummary, PartialResults, StatusState } from '../types/ResponseTypes';
+
+type WithPartialResults = {
+	jobState?: StatusState;
+	jobTasksSummary?: JobTasksSummary;
+	partialResults?: PartialResults;
+};
+
+/**
+ * Primaries the stored results cover while the simulation has not completed; undefined for final results.
+ */
+export function partialRevision(status: WithPartialResults): number | undefined {
+	return status.jobState === StatusState.COMPLETED
+		? undefined
+		: status.partialResults?.simulatedPrimaries;
+}
+
+/**
+ * What partial results are based on, e.g. "37% of primaries, 2 minutes ago".
+ */
+export function partialResultsLabel(
+	status: WithPartialResults,
+	now = new Date()
+): string | undefined {
+	const partial = status.partialResults;
+
+	if (partialRevision(status) === undefined || !partial) return undefined;
+	const requested = status.jobTasksSummary?.requestedPrimaries;
+	const share = requested
+		? `${Math.floor((100 * partial.simulatedPrimaries) / requested)}% of primaries`
+		: `${partial.simulatedPrimaries} primaries`;
+
+	return `${share}, ${formatDistance(new Date(partial.time), now, { addSuffix: true })}`;
+}
diff --git a/src/util/taskTotals.test.ts b/src/util/taskTotals.test.ts
new file mode 100644
index 000000000..a02171f65
--- /dev/null
+++ b/src/util/taskTotals.test.ts
@@ -0,0 +1,59 @@
+import { StatusState } from '../types/ResponseTypes';
+import { taskTotals } from './taskTotals';
+
+describe('taskTotals', () => {
+	it('reads the totals from the server summary', () => {
+		expect(
+			taskTotals({
+				jobTasksSummary: {
+					ntasks: 3,
+					taskStates: {
+						[StatusState.COMPLETED]: 1,
+						[StatusState.FAILED]: 1,
+						[StatusState.RUNNING]: 1
+					},
+					requestedPrimaries: 3000,
+					simulatedPrimaries: 2400
+				}
+			})
+		).toEqual({
+			ntasks: 3,
+			requestedPrimaries: 3000,
+			simulatedPrimaries: 2400,
+			finishedTasks: 2
+		});
+	});
+
+	it('computes the same totals from a task list', () => {
+		expect(
+			taskTotals({
+				jobTasksStatus: [
+					{
+						taskState: StatusState.COMPLETED,
+						requestedPrimaries: 1000,
+						simulatedPrimaries: 1000
+					},
+					{
+						taskState: StatusState.FAILED,
+						requestedPrimaries: 1000,
+						simulatedPrimaries: 1000
+					},
+					{
+						taskState: StatusState.RUNNING,
+						requestedPrimaries: 1000,
+						simulatedPrimaries: 400
+					}
+				]
+			})
+		).toEqual({
+			ntasks: 3,
+			requestedPrimaries: 3000,
+			simulatedPrimaries: 2400,
+			finishedTasks: 2
+		});
+	});
+
+	it('has nothing to say without a summary or a list', () => {
+		expect(taskTotals({})).toBeUndefined();
+	});
+});
diff --git a/src/util/taskTotals.ts b/src/util/taskTotals.ts
new file mode 100644
index 000000000..ca1fe7c39
--- /dev/null
+++ b/src/util/taskTotals.ts
@@ -0,0 +1,44 @@
+import { JobTasksSummary, StatusState, TaskUnknownStatus } from '../types/ResponseTypes';
+
+export type TaskTotals = {
+	ntasks: number;
+	requestedPrimaries: number;
+	simulatedPrimaries: number;
+	finishedTasks: number;
+};
+
+/**
+ * Totals over the tasks of a simulation: from the server's summary, or from the task list
+ * where only the list is known (simulations run in the browser).
+ */
+export function taskTotals(status: {
+	jobTasksSummary?: JobTasksSummary;
+	jobTasksStatus?: TaskUnknownStatus[];
+}): TaskTotals | undefined {
+	const summary = status.jobTasksSummary;
+
+	if (summary) {
+		const states = summary.taskStates;
+
+		return {
+			ntasks: summary.ntasks,
+			requestedPrimaries: summary.requestedPrimaries,
+			simulatedPrimaries: summary.simulatedPrimaries,
+			finishedTasks: (states[StatusState.COMPLETED] ?? 0) + (states[StatusState.FAILED] ?? 0)
+		};
+	}
+
+	return status.jobTasksStatus?.reduce<TaskTotals>(
+		(totals, task) => ({
+			ntasks: totals.ntasks + 1,
+			requestedPrimaries: totals.requestedPrimaries + (task.requestedPrimaries ?? 0),
+			simulatedPrimaries: totals.simulatedPrimaries + (task.simulatedPrimaries ?? 0),
+			finishedTasks:
+				totals.finishedTasks +
+				(task.taskState === StatusState.COMPLETED || task.taskState === StatusState.FAILED
+					? 1
+					: 0)
+		}),
+		{ ntasks: 0, requestedPrimaries: 0, simulatedPrimaries: 0, finishedTasks: 0 }
+	);
+}