diff --git a/src/App.svelte b/src/App.svelte
index a52b9cec..70a4490e 100644
--- a/src/App.svelte
+++ b/src/App.svelte
@@ -454,9 +454,10 @@ import { startMusicToolbox } from './lib/musicToolbox'
 			import('./lib/wireErrors'),
 			import('./lib/safeStorage'),
 			import('./lib/sceneBudget'),
-			import('./lib/overloadGuard')
-      ]).then(([sceneStore, appStore, flowStore, meshEdit, vrControls, autosave, voiceChat, audioEngineLib, musicClockLib, audioDevicesLib, audioPatchLib, vrPatchLib, musicToolboxLib, micCaptureLib, annotationsHandler, flowRuntime, history, materialsHandler, objectActions, commandsHandler, moduleSDK, drawModeLib, pathCapture, lockControl, prefabsLib, physics, jointsLib, possessLib, handModelsLib, terrainSculptLib, userModulesLib, environmentLib, sceneMusicLib, animatedImports, fileHandler, fileWindowsLib, sceneBounds, cameraClip, ping, sessionsLib, geometryEdit, lightParams, shadowDefaultsLib, paletteLib, viewModeLib, inputRuntimeLib, shortcutsLib, themesLib, vrRadialMenu, vrPaletteLib, vrWindowPosesLib, vrKeyboardLib, faceEditLib, meshToolParamsLib, avatarModelLib, explorerLib, bottomDock, explorerDrop, assetShare, soundRuntime, dungeonPlay, sceneAssetsLib, THREE, GLTFExporterModule, snappingLib, flowSocketsLib, networkQualityLib, packsLib, customNodesLib, nodesHandlerLib, nodeCatalogLib, objectMenuLib, animationPreviewLib, aiProvidersLib, aiToolsLib, aiAssistantLib, meshProvidersLib, meshJobsLib, flowGraphsLib, objectFlowLib, peerServerLib, cloudHooksLib, cloudPluginLib, connectionStateLib, peerApprovalLib, particleRuntimeLib, particleActionsLib, particlePresetsLib, versionLib, whatsNewLib, confirmDialogLib, scenePhysicsLib, playInteractLib, moveSmoothingLib, playSettingsLib, colliderSpecLib, colliderHelpersLib, colliderEditLib, editSessionLib, trackpadNavLib, vrSleeveLib, gridSettingsLib, viewPrefsLib, cameraBookmarksLib, cameraObjectsLib, cameraHelpersLib, onionSkinLib, cameraPreviewLib, addObjectsLib, cameraPipLib, inputDeviceLib, sceneTemplatesLib, bvhPickingLib, multiTransformLib, objectOriginLib, moduleGalleryLib, uvEditorLib, uvUnwrapLib, meshTopologyLib, meshBudgetLib, proportionalLib, proportionalRingLib, scenePickLib, snapEngineLib, meshPivotLib, selectionPrefsLib, editOverlaysLib, objectPermissionsLib, scenePostLib, postEffectsLib, viewportOverridesLib, postprocessingModule, shaderBackendsLib, shaderGraphLib, shaderSyncLib, shaderTexturesLib, shaderCatalogLib, unitsLib, postBackendsLib, workspaceLib, editResumeLib, moduleRequirementsLib, hudDocsLib, hudSyncLib, idbLib, hudKindsLib, hudImagesLib, gameStateLib, gameSyncLib, hudActionsLib, moduleNodeIOLib, moduleToolboxesLib, splineTubeLib, splineToolLib, splineEditLib, terrainCarveLib, flattenActionsLib, hudViewportDragLib, gamepadPrefsLib, charControllerLib, hudRichTextLib, moduleHudKindsLib, hudMinimapLib, hudArrangeLib, gamePresenceLib, levelsLib, peerVarsLib, projectManifestLib, projectFileLib, transientObjectsLib, spawnerLib, triggerSyncLib, saveNameLib, sceneIdentityLib, importDuplicatesLib, peerScenesLib, sharedLibraryLib, transferLedgerLib, explorerViewLib, filePreviewLib, saveAsLib, windowTabsLib, colocationLib, colocationCalibrateLib, colocationPresenceLib, xrAnchorsLib, colocationAnchorsLib, colocationNudgeLib, mountedVolumesLib, storageUsageLib, scenePrivacyLib, touchControlsLib, playModeLib, objectListNavLib, inviteLinksLib, helperLayerLib, explorerClipboardLib, diagnosticsLib, wireValidateLib, wireErrorsLib, safeStorageLib, sceneBudgetLib, overloadGuardLib]) => {
-        window.__stores = { ...sceneStore, ...appStore, ...flowStore, meshEdit, vrControls, autosave, voiceChat, audioEngine: audioEngineLib, musicClock: musicClockLib, audioDevices: audioDevicesLib, audioPatch: audioPatchLib, vrPatch: vrPatchLib, musicToolbox: musicToolboxLib, micCapture: micCaptureLib, annotationsHandler, flowRuntime, history, materialsHandler, objectActions, commandsHandler, moduleSDK, drawMode: drawModeLib, pathCapture, lockControl, prefabs: prefabsLib, physics, joints: jointsLib, possess: possessLib, handModels: handModelsLib, terrainSculpt: terrainSculptLib, userModules: userModulesLib, environment: environmentLib, sceneMusic: sceneMusicLib, animatedImports, fileHandler, fileWindows: fileWindowsLib, sceneBounds, cameraClip, ping, sessions: sessionsLib, geometryEdit, lightParams, shadowDefaults: shadowDefaultsLib, palette: paletteLib, viewModeCtl: viewModeLib, inputRuntime: inputRuntimeLib, shortcutsRegistry: shortcutsLib, themes: themesLib, vrRadialMenu, vrPalette: vrPaletteLib, vrWindowPoses: vrWindowPosesLib, vrKeyboard: vrKeyboardLib, faceEdit: faceEditLib, meshToolParams: meshToolParamsLib, avatarModel: avatarModelLib, explorer: explorerLib, bottomDock, explorerDrop, assetShare, soundRuntime, dungeonPlay, sceneAssets: sceneAssetsLib, THREE, GLTFExporterModule, snapping: snappingLib, flowSockets: flowSocketsLib, networkQuality: networkQualityLib, packs: packsLib, customNodes: customNodesLib, nodesHandler: nodesHandlerLib, nodeCatalog: nodeCatalogLib, objectMenu: objectMenuLib, animationPreview: animationPreviewLib, aiProviders: aiProvidersLib, aiTools: aiToolsLib, aiAssistant: aiAssistantLib, meshProviders: meshProvidersLib, meshJobs: meshJobsLib, flowGraphsCtl: flowGraphsLib, objectFlow: objectFlowLib, peerServer: peerServerLib, cloudHooks: cloudHooksLib, cloudPlugin: cloudPluginLib, connectionState: connectionStateLib, peerApproval: peerApprovalLib, particleRuntime: particleRuntimeLib, particleActions: particleActionsLib, particlePresets: particlePresetsLib, version: versionLib, whatsNew: whatsNewLib, confirmDialog: confirmDialogLib, scenePhysics: scenePhysicsLib, playInteract: playInteractLib, moveSmoothing: moveSmoothingLib, playSettings: playSettingsLib, colliderSpec: colliderSpecLib, colliderHelpers: colliderHelpersLib, colliderEdit: colliderEditLib, editSession: editSessionLib, trackpadNav: trackpadNavLib, vrSleeve: vrSleeveLib, gridSettings: gridSettingsLib, viewPrefs: viewPrefsLib, cameraBookmarks: cameraBookmarksLib, cameraObjects: cameraObjectsLib, cameraHelpers: cameraHelpersLib, onionSkin: onionSkinLib, cameraPreview: cameraPreviewLib, addObjects: addObjectsLib, cameraPip: cameraPipLib, inputDevice: inputDeviceLib, sceneTemplates: sceneTemplatesLib, bvhPicking: bvhPickingLib, multiTransform: multiTransformLib, objectOrigin: objectOriginLib, moduleGallery: moduleGalleryLib, uvEditor: uvEditorLib, uvUnwrap: uvUnwrapLib, meshTopology: meshTopologyLib, meshBudget: meshBudgetLib, proportional: proportionalLib, proportionalRing: proportionalRingLib, scenePick: scenePickLib, snapEngine: snapEngineLib, meshPivot: meshPivotLib, selectionPrefs: selectionPrefsLib, editOverlays: editOverlaysLib, objectPermissions: objectPermissionsLib, scenePost: scenePostLib, postEffects: postEffectsLib, viewportOverrides: viewportOverridesLib, postprocessing: postprocessingModule, shaderBackends: shaderBackendsLib, shaderGraph: shaderGraphLib, shaderSync: shaderSyncLib, shaderTextures: shaderTexturesLib, shaderCatalog: shaderCatalogLib, units: unitsLib, postBackends: postBackendsLib, workspace: workspaceLib, editResume: editResumeLib, moduleRequirements: moduleRequirementsLib, hudDocs: hudDocsLib, hudSync: hudSyncLib, idb: idbLib, hudKinds: hudKindsLib, hudImages: hudImagesLib, gameState: gameStateLib, gameSync: gameSyncLib, hudActions: hudActionsLib, moduleNodeIO: moduleNodeIOLib, moduleToolboxes: moduleToolboxesLib, splineTube: splineTubeLib, splineTool: splineToolLib, splineEdit: splineEditLib, terrainCarve: terrainCarveLib, flattenActions: flattenActionsLib, hudViewportDrag: hudViewportDragLib, gamepadPrefs: gamepadPrefsLib, charController: charControllerLib, hudRichText: hudRichTextLib, moduleHudKinds: moduleHudKindsLib, hudMinimap: hudMinimapLib, hudArrange: hudArrangeLib, gamePresence: gamePresenceLib, levels: levelsLib, peerVars: peerVarsLib, projectManifest: projectManifestLib, projectFile: projectFileLib, transientObjects: transientObjectsLib, spawner: spawnerLib, triggerSync: triggerSyncLib, saveName: saveNameLib, sceneIdentity: sceneIdentityLib, importDuplicates: importDuplicatesLib, peerScenes: peerScenesLib, sharedLibrary: sharedLibraryLib, transferLedger: transferLedgerLib, explorerView: explorerViewLib, filePreview: filePreviewLib, saveAs: saveAsLib, windowTabs: windowTabsLib, colocation: colocationLib, colocationCalibrate: colocationCalibrateLib, colocationPresence: colocationPresenceLib, xrAnchors: xrAnchorsLib, colocationAnchors: colocationAnchorsLib, colocationNudge: colocationNudgeLib, mountedVolumes: mountedVolumesLib, storageUsage: storageUsageLib, scenePrivacy: scenePrivacyLib, touchControls: touchControlsLib, playMode: playModeLib, objectListNav: objectListNavLib, inviteLinks: inviteLinksLib, helperLayer: helperLayerLib, explorerClipboard: explorerClipboardLib, diagnostics: diagnosticsLib, wireValidate: wireValidateLib, wireErrors: wireErrorsLib, safeStorage: safeStorageLib, sceneBudget: sceneBudgetLib, overloadGuard: overloadGuardLib }
+			import('./lib/overloadGuard'),
+			import('./lib/qualityGovernor')
+      ]).then(([sceneStore, appStore, flowStore, meshEdit, vrControls, autosave, voiceChat, audioEngineLib, musicClockLib, audioDevicesLib, audioPatchLib, vrPatchLib, musicToolboxLib, micCaptureLib, annotationsHandler, flowRuntime, history, materialsHandler, objectActions, commandsHandler, moduleSDK, drawModeLib, pathCapture, lockControl, prefabsLib, physics, jointsLib, possessLib, handModelsLib, terrainSculptLib, userModulesLib, environmentLib, sceneMusicLib, animatedImports, fileHandler, fileWindowsLib, sceneBounds, cameraClip, ping, sessionsLib, geometryEdit, lightParams, shadowDefaultsLib, paletteLib, viewModeLib, inputRuntimeLib, shortcutsLib, themesLib, vrRadialMenu, vrPaletteLib, vrWindowPosesLib, vrKeyboardLib, faceEditLib, meshToolParamsLib, avatarModelLib, explorerLib, bottomDock, explorerDrop, assetShare, soundRuntime, dungeonPlay, sceneAssetsLib, THREE, GLTFExporterModule, snappingLib, flowSocketsLib, networkQualityLib, packsLib, customNodesLib, nodesHandlerLib, nodeCatalogLib, objectMenuLib, animationPreviewLib, aiProvidersLib, aiToolsLib, aiAssistantLib, meshProvidersLib, meshJobsLib, flowGraphsLib, objectFlowLib, peerServerLib, cloudHooksLib, cloudPluginLib, connectionStateLib, peerApprovalLib, particleRuntimeLib, particleActionsLib, particlePresetsLib, versionLib, whatsNewLib, confirmDialogLib, scenePhysicsLib, playInteractLib, moveSmoothingLib, playSettingsLib, colliderSpecLib, colliderHelpersLib, colliderEditLib, editSessionLib, trackpadNavLib, vrSleeveLib, gridSettingsLib, viewPrefsLib, cameraBookmarksLib, cameraObjectsLib, cameraHelpersLib, onionSkinLib, cameraPreviewLib, addObjectsLib, cameraPipLib, inputDeviceLib, sceneTemplatesLib, bvhPickingLib, multiTransformLib, objectOriginLib, moduleGalleryLib, uvEditorLib, uvUnwrapLib, meshTopologyLib, meshBudgetLib, proportionalLib, proportionalRingLib, scenePickLib, snapEngineLib, meshPivotLib, selectionPrefsLib, editOverlaysLib, objectPermissionsLib, scenePostLib, postEffectsLib, viewportOverridesLib, postprocessingModule, shaderBackendsLib, shaderGraphLib, shaderSyncLib, shaderTexturesLib, shaderCatalogLib, unitsLib, postBackendsLib, workspaceLib, editResumeLib, moduleRequirementsLib, hudDocsLib, hudSyncLib, idbLib, hudKindsLib, hudImagesLib, gameStateLib, gameSyncLib, hudActionsLib, moduleNodeIOLib, moduleToolboxesLib, splineTubeLib, splineToolLib, splineEditLib, terrainCarveLib, flattenActionsLib, hudViewportDragLib, gamepadPrefsLib, charControllerLib, hudRichTextLib, moduleHudKindsLib, hudMinimapLib, hudArrangeLib, gamePresenceLib, levelsLib, peerVarsLib, projectManifestLib, projectFileLib, transientObjectsLib, spawnerLib, triggerSyncLib, saveNameLib, sceneIdentityLib, importDuplicatesLib, peerScenesLib, sharedLibraryLib, transferLedgerLib, explorerViewLib, filePreviewLib, saveAsLib, windowTabsLib, colocationLib, colocationCalibrateLib, colocationPresenceLib, xrAnchorsLib, colocationAnchorsLib, colocationNudgeLib, mountedVolumesLib, storageUsageLib, scenePrivacyLib, touchControlsLib, playModeLib, objectListNavLib, inviteLinksLib, helperLayerLib, explorerClipboardLib, diagnosticsLib, wireValidateLib, wireErrorsLib, safeStorageLib, sceneBudgetLib, overloadGuardLib, qualityGovernorLib]) => {
+        window.__stores = { ...sceneStore, ...appStore, ...flowStore, meshEdit, vrControls, autosave, voiceChat, audioEngine: audioEngineLib, musicClock: musicClockLib, audioDevices: audioDevicesLib, audioPatch: audioPatchLib, vrPatch: vrPatchLib, musicToolbox: musicToolboxLib, micCapture: micCaptureLib, annotationsHandler, flowRuntime, history, materialsHandler, objectActions, commandsHandler, moduleSDK, drawMode: drawModeLib, pathCapture, lockControl, prefabs: prefabsLib, physics, joints: jointsLib, possess: possessLib, handModels: handModelsLib, terrainSculpt: terrainSculptLib, userModules: userModulesLib, environment: environmentLib, sceneMusic: sceneMusicLib, animatedImports, fileHandler, fileWindows: fileWindowsLib, sceneBounds, cameraClip, ping, sessions: sessionsLib, geometryEdit, lightParams, shadowDefaults: shadowDefaultsLib, palette: paletteLib, viewModeCtl: viewModeLib, inputRuntime: inputRuntimeLib, shortcutsRegistry: shortcutsLib, themes: themesLib, vrRadialMenu, vrPalette: vrPaletteLib, vrWindowPoses: vrWindowPosesLib, vrKeyboard: vrKeyboardLib, faceEdit: faceEditLib, meshToolParams: meshToolParamsLib, avatarModel: avatarModelLib, explorer: explorerLib, bottomDock, explorerDrop, assetShare, soundRuntime, dungeonPlay, sceneAssets: sceneAssetsLib, THREE, GLTFExporterModule, snapping: snappingLib, flowSockets: flowSocketsLib, networkQuality: networkQualityLib, packs: packsLib, customNodes: customNodesLib, nodesHandler: nodesHandlerLib, nodeCatalog: nodeCatalogLib, objectMenu: objectMenuLib, animationPreview: animationPreviewLib, aiProviders: aiProvidersLib, aiTools: aiToolsLib, aiAssistant: aiAssistantLib, meshProviders: meshProvidersLib, meshJobs: meshJobsLib, flowGraphsCtl: flowGraphsLib, objectFlow: objectFlowLib, peerServer: peerServerLib, cloudHooks: cloudHooksLib, cloudPlugin: cloudPluginLib, connectionState: connectionStateLib, peerApproval: peerApprovalLib, particleRuntime: particleRuntimeLib, particleActions: particleActionsLib, particlePresets: particlePresetsLib, version: versionLib, whatsNew: whatsNewLib, confirmDialog: confirmDialogLib, scenePhysics: scenePhysicsLib, playInteract: playInteractLib, moveSmoothing: moveSmoothingLib, playSettings: playSettingsLib, colliderSpec: colliderSpecLib, colliderHelpers: colliderHelpersLib, colliderEdit: colliderEditLib, editSession: editSessionLib, trackpadNav: trackpadNavLib, vrSleeve: vrSleeveLib, gridSettings: gridSettingsLib, viewPrefs: viewPrefsLib, cameraBookmarks: cameraBookmarksLib, cameraObjects: cameraObjectsLib, cameraHelpers: cameraHelpersLib, onionSkin: onionSkinLib, cameraPreview: cameraPreviewLib, addObjects: addObjectsLib, cameraPip: cameraPipLib, inputDevice: inputDeviceLib, sceneTemplates: sceneTemplatesLib, bvhPicking: bvhPickingLib, multiTransform: multiTransformLib, objectOrigin: objectOriginLib, moduleGallery: moduleGalleryLib, uvEditor: uvEditorLib, uvUnwrap: uvUnwrapLib, meshTopology: meshTopologyLib, meshBudget: meshBudgetLib, proportional: proportionalLib, proportionalRing: proportionalRingLib, scenePick: scenePickLib, snapEngine: snapEngineLib, meshPivot: meshPivotLib, selectionPrefs: selectionPrefsLib, editOverlays: editOverlaysLib, objectPermissions: objectPermissionsLib, scenePost: scenePostLib, postEffects: postEffectsLib, viewportOverrides: viewportOverridesLib, postprocessing: postprocessingModule, shaderBackends: shaderBackendsLib, shaderGraph: shaderGraphLib, shaderSync: shaderSyncLib, shaderTextures: shaderTexturesLib, shaderCatalog: shaderCatalogLib, units: unitsLib, postBackends: postBackendsLib, workspace: workspaceLib, editResume: editResumeLib, moduleRequirements: moduleRequirementsLib, hudDocs: hudDocsLib, hudSync: hudSyncLib, idb: idbLib, hudKinds: hudKindsLib, hudImages: hudImagesLib, gameState: gameStateLib, gameSync: gameSyncLib, hudActions: hudActionsLib, moduleNodeIO: moduleNodeIOLib, moduleToolboxes: moduleToolboxesLib, splineTube: splineTubeLib, splineTool: splineToolLib, splineEdit: splineEditLib, terrainCarve: terrainCarveLib, flattenActions: flattenActionsLib, hudViewportDrag: hudViewportDragLib, gamepadPrefs: gamepadPrefsLib, charController: charControllerLib, hudRichText: hudRichTextLib, moduleHudKinds: moduleHudKindsLib, hudMinimap: hudMinimapLib, hudArrange: hudArrangeLib, gamePresence: gamePresenceLib, levels: levelsLib, peerVars: peerVarsLib, projectManifest: projectManifestLib, projectFile: projectFileLib, transientObjects: transientObjectsLib, spawner: spawnerLib, triggerSync: triggerSyncLib, saveName: saveNameLib, sceneIdentity: sceneIdentityLib, importDuplicates: importDuplicatesLib, peerScenes: peerScenesLib, sharedLibrary: sharedLibraryLib, transferLedger: transferLedgerLib, explorerView: explorerViewLib, filePreview: filePreviewLib, saveAs: saveAsLib, windowTabs: windowTabsLib, colocation: colocationLib, colocationCalibrate: colocationCalibrateLib, colocationPresence: colocationPresenceLib, xrAnchors: xrAnchorsLib, colocationAnchors: colocationAnchorsLib, colocationNudge: colocationNudgeLib, mountedVolumes: mountedVolumesLib, storageUsage: storageUsageLib, scenePrivacy: scenePrivacyLib, touchControls: touchControlsLib, playMode: playModeLib, objectListNav: objectListNavLib, inviteLinks: inviteLinksLib, helperLayer: helperLayerLib, explorerClipboard: explorerClipboardLib, diagnostics: diagnosticsLib, wireValidate: wireValidateLib, wireErrors: wireErrorsLib, safeStorage: safeStorageLib, sceneBudget: sceneBudgetLib, overloadGuard: overloadGuardLib, qualityGovernor: qualityGovernorLib }
       })
     }
   })
diff --git a/src/components/Outline.svelte b/src/components/Outline.svelte
index 2abcba88..d60fda87 100644
--- a/src/components/Outline.svelte
+++ b/src/components/Outline.svelte
@@ -38,6 +38,7 @@
 	} from 'postprocessing';
 	import { onMount, onDestroy, untrack } from 'svelte';
 	import { renderPaused } from '$lib/overloadGuard';
+	import { qualityOverrides, ingestDrawGap } from '$lib/qualityGovernor';
 	// 16-Q4: the camera preview window renders as an inset viewport of THIS renderer
 	import { pipRect, pipTarget, glRect } from '$lib/cameraPip';
 	import { buildCamera } from '$lib/cameraObjects';
@@ -46,7 +47,7 @@
 	let outlineEffectSelected: OutlineEffect | null = null;
 	let outlineEffectLocked: OutlineEffect | null = null;
 
-	const { scene, renderer, camera, size, autoRender, renderStage } = useThrelte();
+	const { scene, renderer, camera, size, autoRender, renderStage, dpr } = useThrelte();
 	const composer = new EffectComposer(renderer);
 	composer.removeAllPasses();
 	const renderPass = new RenderPass(scene, camera.current);
@@ -215,10 +216,13 @@
 		// displays, so its output was upsampled and read as a shifted "ghost" of the
 		// shading offset from the objects. The per-kind `resize` hook carries that
 		// lesson in the registry rather than hardcoded here.
-		const dpr = renderer.getPixelRatio ? renderer.getPixelRatio() : 1;
+		// 26-D: the governor changes the pixel ratio WITHOUT changing the CSS size, so the
+		// composer has to follow the dpr too or its targets stay at the old resolution
+		void $dpr;
+		const pixelRatio = renderer.getPixelRatio ? renderer.getPixelRatio() : 1;
 		composer.setSize($size.width, $size.height);
 		for (const instance of stackInstances)
-			instance.def?.resize?.(instance.object, $size.width, $size.height, dpr);
+			instance.def?.resize?.(instance.object, $size.width, $size.height, pixelRatio);
 	});
 	// L4: the capability gate now covers the WHOLE stack, not just AO (see
 	// viewMode.postSupported for the three-r185 + Chromium<=150 story, why the
@@ -253,14 +257,18 @@
 		// changes (measured: setting a camera to No files replaced rendered nothing new).
 		void $postStacks;
 		void $lookOverride;
+		// 26-D: the quality governor's post steps — AO first (the personal chip reads as plain
+		// shaded, an authored AO entry is dropped), then the whole stack. LOCAL overrides: the
+		// authored document is never touched, so a peer's look is unchanged
+		const reduced = $qualityOverrides;
 		const entries = effectivePostStack({
 			stack: resolvedDoc(POST_SCENE_KEY),
 			cameraStack: /** @type {any} */ (throughCamera ? resolvedDoc(throughCamera) : null),
-			mode: $viewMode,
-			localEnabled: $postEnabledLocal,
+			mode: reduced.aoOff && $viewMode === 'shaded-ao' ? 'shaded' : $viewMode,
+			localEnabled: $postEnabledLocal && !reduced.postOff,
 			postOk,
 			postWarm
-		});
+		}).filter((entry) => !(reduced.aoOff && entry.kind === 'ao'));
 		const signature = postStackSignature(entries);
 		if (signature === stackSignature) return;
 		stackSignature = signature;
@@ -330,9 +338,22 @@
 	let renderIsPaused = false;
 	const stopPauseWatch = renderPaused.subscribe((value) => (renderIsPaused = !!value));
 	onDestroy(stopPauseWatch);
+	// 26-D THE INGEST DRAW GAP (26-E's finding): while a big received scene drains through
+	// slow frames, draw at most one frame per gap — every object's parse waits for a frame to
+	// pass, so a joiner redrawing a 2,000-object scene 30 times a second was starving its own
+	// receive queue (3,000 objects: ~180s drawing, 5.6s not). Never in XR, like the pause.
+	let drawGapMs = 0;
+	let lastDrawAt = 0;
+	const stopGapWatch = ingestDrawGap.subscribe((value) => (drawGapMs = value));
+	onDestroy(stopGapWatch);
 	useTask(
 		(delta) => {
 			if (renderIsPaused && !renderer.xr.isPresenting) return;
+			if (drawGapMs > 0 && !renderer.xr.isPresenting) {
+				const drawNow = performance.now();
+				if (drawNow - lastDrawAt < drawGapMs) return;
+				lastDrawAt = drawNow;
+			}
 			// In WebXR the EffectComposer can't be used: its passes render to canvas-sized
 			// targets, not the XR framebuffer, so blitting them mismatches sizes
 			// (GL_INVALID_FRAMEBUFFER_OPERATION) and nothing reaches the headset (dark
@@ -460,6 +481,8 @@
 					return index >= 0 ? 'stack:' + (stackPlan[index]?.kinds ?? []).join('+') : 'other';
 				}),
 				composerPasses: ((composer as any).passes ?? []).length,
+				// 26-D: the composer's own buffer, which must follow a governor dpr change
+				composerBufferWidth: (composer as any).inputBuffer?.width ?? null,
 				outlinedSelected: outlineEffectSelected?.selection.size ?? 0,
 				outlinedLocked: outlineEffectLocked?.selection.size ?? 0,
 				stackPasses: stackPasses.length,
diff --git a/src/components/Scene.svelte b/src/components/Scene.svelte
index 1e8a8915..f47c9396 100644
--- a/src/components/Scene.svelte
+++ b/src/components/Scene.svelte
@@ -1,6 +1,7 @@
 <script lang="ts">
 	import * as THREE from 'three';
-	import { onMount } from 'svelte';
+	import { onMount, onDestroy } from 'svelte';
+	import { qualityOverrides } from '$lib/qualityGovernor';
 	import { T, useTask, useThrelte } from '@threlte/core';
 	import { Environment, interactivity, OrbitControls, TransformControls } from '@threlte/extras';
 	import { XR, Controller, Hand, useHand } from '@threlte/xr'
@@ -93,7 +94,22 @@
 	import { Mesh, Vector3 } from 'three'
 
 
-	let { scene, camera, renderer } = useThrelte();
+	let { scene, camera, renderer, dpr } = useThrelte();
+
+	// 26-D: the quality governor's two knobs that live here. Resolution goes through
+	// threlte's OWN dpr (renderer.setPixelRatio directly would be undone by threlte's resize
+	// effect), and only once the governor has asked for something — at full quality this
+	// never touches the dpr, so threlte keeps following devicePixelRatio as it always did.
+	// The presence halving is read by the camera send below.
+	let presenceSlow = false;
+	let appliedDprScale = 1;
+	const stopQualityWatch = qualityOverrides.subscribe((o) => {
+		presenceSlow = o.presenceSlow;
+		if (o.dprScale === appliedDprScale) return;
+		appliedDprScale = o.dprScale;
+		dpr.set((typeof window !== 'undefined' ? window.devicePixelRatio || 1 : 1) * o.dprScale);
+	});
+	onDestroy(stopQualityWatch);
 
 	$globalScene = scene; // console.log($globalScene)
 	$globalRenderer = renderer;
@@ -297,7 +313,8 @@
 			// receives ~800 a second. The movement threshold is unchanged; this only bounds
 			// HOW OFTEN, which is the `vrhands` pattern one block below. Golden rule 11: a
 			// receiver eases between samples, we never raise a send rate to paper over it.
-			const camGapMs = $isVRMode ? 33 : 50;
+			// 26-D: the governor's last step halves it again (a receiver eases, rule 11)
+			const camGapMs = ($isVRMode ? 33 : 50) * (presenceSlow ? 2 : 1);
 			const nowMs = performance.now();
 			if ((camContentPos.distanceTo(lastCameraPosition) > ($isVRMode ? 0.0001 : 0.01) ||
 				camContentQuat.angleTo(lastCameraQuaternion) > THREE.MathUtils.degToRad(1)) &&
diff --git a/src/components/menu/Controls.svelte b/src/components/menu/Controls.svelte
index b47254a8..104282e5 100644
--- a/src/components/menu/Controls.svelte
+++ b/src/components/menu/Controls.svelte
@@ -6,6 +6,8 @@
 	// 24-B2: keyboard navigation in the object list (the Explorer's gridKeydown shape)
 	import { visibleObjectRows, withExpanded, typeAheadIndex } from '$lib/objectListNav';
 	import { sceneMetrics, statsOpen, worstTier, budgetRows } from '$lib/sceneBudget';
+	import { qualityState, pinQuality, releaseQuality } from '$lib/qualityGovernor';
+	import { showToast as showQualityToast } from '../../stores/appStore';
 	import { keyOf } from '$lib/keyOf';
 	import { systemGroupNames } from '$lib/moduleSDK';
 	import { ENV_ROOT } from '$lib/environment';
@@ -20,9 +22,9 @@
 	import { sendPing } from '$lib/ping';
 	import { buildObjectMenuItems } from '$lib/objectMenu';
 	import * as THREE from 'three';
-	import { onMount, setContext, tick } from 'svelte';
+	import { onMount, setContext, tick, untrack } from 'svelte';
 	import { createGesture } from '$lib/modalGrab';
-	import { writable } from 'svelte/store';
+	import { writable, get } from 'svelte/store';
 	import { shareObject } from '$lib/objectPermissions';
 	import Objects from './Objects.svelte';
 	import LocalObjects from './LocalObjects.svelte';
@@ -520,6 +522,39 @@
 		return 'Scene budget: over on ' + over.map((r) => r.label.toLowerCase()).join(', ') + '. Click for statistics.';
 	});
 
+	// 26-D: THE QUALITY CHIP. The governor acts on its own, so it has to be SEEN acting and
+	// be answerable in one click — an automatic change a person cannot see or undo is just a
+	// different kind of broken (26-G's rule). Two states, one button: reducing on its own
+	// (click keeps it), or held (click gives full quality back). A direct listener for the
+	// same reason as openStats.
+	const qualityTitle = $derived.by(() => {
+		const q = $qualityState;
+		const what = q.labels.join(', ').toLowerCase();
+		return q.pinned
+			? 'Held at reduced quality (' + what + '). Click to restore full quality.'
+			: 'This scene is heavy for this device, so drawing was reduced: ' + what + '. It comes back on its own when frames recover. Click to keep it this way.';
+	});
+	function qualityChipClick(node: HTMLElement) {
+		const click = () => (get(qualityState).pinned ? releaseQuality() : pinQuality());
+		node.addEventListener('click', click);
+		return { destroy() { node.removeEventListener('click', click); } };
+	}
+	// …and once per session, a toast when it FIRST acts, because the chip lives in the object
+	// list's footer and that window can be closed
+	let qualityToasted = false;
+	$effect(() => {
+		const q = $qualityState;
+		if (q.level > 0 && !qualityToasted) {
+			qualityToasted = true;
+			untrack(() =>
+				showQualityToast('Quality reduced — this scene is heavy for this device (' + q.labels.join(', ').toLowerCase() + '). It comes back on its own.', [
+					{ label: 'Restore full quality', action: () => releaseQuality() },
+					{ label: 'Keep it', action: () => pinQuality() }
+				])
+			);
+		}
+	});
+
 	// bottom status line: totals across the whole tree (N objects · M hidden)
 	let objectCount = $state(0);
 	let hiddenCount = $state(0);
@@ -2328,6 +2363,18 @@
 	<!-- 26-A: THE BUDGET METER. One dot beside the count that a person can learn in a
 	     second, next to the one number that already says how big the scene is. It opens
 	     the Statistics window, because a warning you cannot act on is a decoration. -->
+	{#if $qualityState.level > 0 || $qualityState.pinned}
+		<button
+			id="quality-chip"
+			class="shrink-0 bg-amber-100 px-2 py-0.5 text-left text-[10px] text-amber-800 dark:bg-amber-900/60 dark:text-amber-200"
+			data-level={$qualityState.level}
+			data-pinned={$qualityState.pinned ? 'true' : 'false'}
+			title={qualityTitle}
+			use:qualityChipClick
+		>
+			Reduced quality{$qualityState.pinned ? ' · held' : ' (scene is heavy)'}
+		</button>
+	{/if}
 	<button
 		id="object-count"
 		class="shrink-0 rounded-bl rounded-br bg-gray-100 px-2 py-0.5 text-left text-[10px] text-gray-500 dark:bg-gray-700 dark:text-gray-300"
diff --git a/src/components/menu/Settings.svelte b/src/components/menu/Settings.svelte
index c85d2e96..6d4d8aea 100644
--- a/src/components/menu/Settings.svelte
+++ b/src/components/menu/Settings.svelte
@@ -24,6 +24,7 @@
 	import { syncedAnimations } from '../../stores/flowStore';
 	import { spatialVoice } from '$lib/voiceChat';
 	import { shadowQuality } from '$lib/lightParams';
+	import { autoQuality } from '$lib/qualityGovernor';
 	import { myHandModel, setMyHandModel } from '$lib/handModels';
 	import { explorerItems } from '$lib/explorer';
 	import { pingColor, pingSound } from '$lib/ping';
@@ -1025,6 +1026,10 @@
 						</svelte:fragment>
 						Caps every light's shadow map size on THIS machine (Off disables shadows entirely; per-light sizes still replicate)
 					</SettingRow>
+					<SettingRow name="Reduce quality when the scene is heavy">
+						<svelte:fragment slot="control"><Checkbox id="auto-quality" bind:checked={$autoQuality} /></svelte:fragment>
+						When a heavy scene cannot keep 30 frames a second on THIS machine, drop shadows, then resolution, then effects, one step at a time, and give each back when frames recover. Never changes the scene for anyone else; the chip beside the object count says when it is active
+					</SettingRow>
 					<SettingRow name="Simulation controls">
 						<svelte:fragment slot="control"><Checkbox bind:checked={$showSimControls} /></svelte:fragment>
 						Show the physics transport (play/pause/stop/reset) at bottom-right. Off by default to avoid confusion with the main play button; the P key still starts/stops the simulation
diff --git a/src/lib/autosave.js b/src/lib/autosave.js
index 2b6f4848..ca7c37f4 100644
--- a/src/lib/autosave.js
+++ b/src/lib/autosave.js
@@ -32,6 +32,7 @@ import { log, registerDiagnosticsSection } from './diagnostics';
 import { captureEditResume, applyEditResume } from './editResume';
 import { disposeTree, keepSet } from './disposeTree';
 import { safeStorage } from './safeStorage';
+import { registerMetricSource } from './sceneBudget';
 
 // Crash safety: snapshots of the scene (GLTF json), the node graph and the
 // camera go to IndexedDB — debounced 30s after any change plus a 3-minute
@@ -61,6 +62,12 @@ const MAX_DEBOUNCE_MS = 300_000;
  *   debounceMs: number, lastSaveAt: number, writes: number, coalesced: number,
  *   lastError: string | null}>}
  */
+// 26-E (roadmap 26 section 3): what the last snapshot cost, for the budget sampler and
+// the stress rig. The status store already held both numbers; nothing sampled them.
+// Registered, not imported by sceneBudget — that module stays a leaf.
+registerMetricSource('autosaveExportMs', () => get(autosaveStatus).lastExportMs || null);
+registerMetricSource('autosaveBytes', () => get(autosaveStatus).lastBytes || null);
+
 export const autosaveStatus = writable({
 	lastExportMs: 0,
 	lastBytes: 0,
diff --git a/src/lib/commandsHandler.svelte.js b/src/lib/commandsHandler.svelte.js
index a4d8a51c..8dba4266 100644
--- a/src/lib/commandsHandler.svelte.js
+++ b/src/lib/commandsHandler.svelte.js
@@ -417,7 +417,20 @@ let loadingStallTimer = null;
  * rejects. Nothing cleared it: the only writer was the Toasts effect, which removes a
  * uuid when its object APPEARS, and an object that never arrives never appears. */
 const LOADING_STALL_MS = 60000;
+let loadingStallMs = LOADING_STALL_MS;
+/** TEST-ONLY: shorten the stall so "silence, not duration" is provable in seconds.
+ * @param {number} [ms] omit to restore the real value */
+export function setLoadingStallMsForTest(ms) {
+    loadingStallMs = Number.isFinite(ms) && /** @type {number} */ (ms) > 0 ? /** @type {number} */ (ms) : LOADING_STALL_MS;
+}
 
+// 26-E: THE STALL IS SILENCE, NOT DURATION. The timer was armed once, at the announcement,
+// and never again — so any transfer that simply took longer than a minute was declared
+// dead while it was still arriving. The stress rig measured exactly that: a joiner
+// receiving 3,000 boxes on a real GPU was still landing ~10 objects a second at 63s when
+// the bar cleared and the toast said "1085 objects never arrived"; all 3,000 arrived by
+// 180s. Every uuid that lands now re-arms it (the `loading` subscription below), so the
+// 60s is measured from the LAST sign of life, which is what M2 meant by a stall.
 function armLoadingStall() {
     clearTimeout(loadingStallTimer);
     loadingStallTimer = setTimeout(() => {
@@ -426,11 +439,56 @@ function armLoadingStall() {
         console.log('Receiving objects: giving up on ' + left.length + ' that never arrived');
         clearLoadingBatch();
         showToast(left.length + ' object' + (left.length === 1 ? '' : 's') + ' never arrived.');
-    }, LOADING_STALL_MS);
+    }, loadingStallMs);
+}
+
+// 26-E (roadmap 26 section 3, "handshake time-to-synced"): how long the last RECEIVED
+// batch took, from its `loading` announcement to the last object landing. The receive
+// side is where the cost is felt, and it is the one moment both ends of the interval
+// are known locally — no clock is compared across peers. LOCAL, never sent.
+/** @type {number} */
+let loadingStartedAt = 0;
+/** @type {number} */
+let loadingAnnounced = 0;
+/** uuids still outstanding when the batch was CLOSED rather than finished (a stall, a
+ * departed sender, a cleared scene) — so a batch that never finished cannot report a
+ * sync time as though it had. */
+let loadingLeftAtClear = 0;
+/** @type {{ms: number, objects: number, complete: boolean, at: number} | null} */
+let lastSync = null;
+/** The last batch that ENDED (finished or closed), or null before one has run. */
+export function lastSyncStats() {
+    return lastSync;
 }
+// Both ends of a batch pass through the store: the Toasts reconcile empties it as the
+// last object appears, and `clearLoadingBatch` empties it on every other way out.
+// Subscribing here sees both without touching either writer.
+/** outstanding count at the last notification, so only PROGRESS re-arms the stall */
+let loadingLastLeft = 0;
+loading.subscribe((/** @type {any} */ left) => {
+    const count = Array.isArray(left) ? left.length : 0;
+    // progress on an open batch: re-arm — but only a timer that is running, never one the
+    // ingest fork parked on purpose while its question is open
+    if (loadingStartedAt && count > 0 && count < loadingLastLeft && loadingStallTimer) armLoadingStall();
+    loadingLastLeft = count;
+    if (!loadingStartedAt || count) return;
+    lastSync = {
+        ms: Math.round(performance.now() - loadingStartedAt),
+        objects: loadingAnnounced,
+        complete: loadingLeftAtClear === 0,
+        at: Date.now()
+    };
+    loadingStartedAt = 0;
+    loadingLeftAtClear = 0;
+});
+// only a batch that FINISHED has a sync time; a closed one says null rather than a
+// number that would read as a fast join
+registerMetricSource('syncMs', () => (lastSync?.complete ? lastSync.ms : null));
+registerMetricSource('syncObjects', () => (lastSync?.complete ? lastSync.objects : null));
 
 /** Close the batch: the bar goes away, the stall timer disarms. Idempotent. */
 export function clearLoadingBatch() {
+    if (loadingStartedAt) loadingLeftAtClear = /** @type {string[]} */ (get(loading)).length;
     clearTimeout(loadingStallTimer);
     loadingStallTimer = null;
     loadingSender = null;
@@ -453,6 +511,9 @@ export async function createLoader(count, uuids, senderId) {
     loading.set(Array.isArray(uuids) ? uuids : []);
     loadingcount.set(count);
     loadingSender = senderId ?? null;
+    // an empty announcement opens nothing to finish, so it starts no clock
+    loadingStartedAt = Array.isArray(uuids) && uuids.length ? performance.now() : 0;
+    loadingAnnounced = Number(count) || 0;
     // 26-C: THE ONE MOMENT the size is known and nothing has been applied. Past it a
     // 4,000-object scene is simply happening to you.
     const verdict = ingestVerdict(liveObjectCount(), count, profileFor(get(globalRenderer)));
diff --git a/src/lib/environment.js b/src/lib/environment.js
index e47ab28e..814c31c7 100644
--- a/src/lib/environment.js
+++ b/src/lib/environment.js
@@ -5,7 +5,7 @@ import { peers } from '../stores/appStore';
 import { sceneRadius } from './sceneBounds';
 import { registerSystemGroup } from './moduleSDK';
 import { createLight } from './geometries.svelte';
-import { cappedShadowSize, shadowQuality } from './lightParams';
+import { cappedShadowSize, shadowsDisabled } from './lightParams';
 import { wireframeActive } from './viewMode';
 import { idbGet, idbPut, idbDelete, idbKeys } from './idb';
 import { safeStorage } from './safeStorage';
@@ -240,7 +240,8 @@ export function applyEnvironment() {
 		// honor a persisted 'off' shadow pref here too: the renderer arrives
 		// after lightParams' first subscribe fires (which would no-op on a null
 		// renderer), so re-assert it on every apply
-		if (renderer.shadowMap) renderer.shadowMap.enabled = get(shadowQuality) !== 'off';
+		// (26-D: through shadowsDisabled, so the quality governor's override survives an apply)
+		if (renderer.shadowMap) renderer.shadowMap.enabled = !shadowsDisabled();
 	}
 
 	const { hemi, sun } = rigLights(scene, !!preset.hemi);
@@ -280,7 +281,7 @@ export function applyEnvironment() {
 	// correctly over the camera feed, and that darkening is what glues a virtual
 	// object to a real table (the sky/fog lift above is the whole AR stand-down;
 	// the sun rig keeps casting untouched)
-	const shadowsOff = get(shadowQuality) === 'off';
+	const shadowsOff = shadowsDisabled();
 	const catcher = shadowCatcher(scene, !!(preset.sun && !shadowsOff));
 	if (catcher) {
 		catcher.visible = !!(preset.sun && !shadowsOff) && !wireframeActive();
diff --git a/src/lib/lightParams.js b/src/lib/lightParams.js
index 75659e4c..8de78721 100644
--- a/src/lib/lightParams.js
+++ b/src/lib/lightParams.js
@@ -2,6 +2,7 @@ import * as THREE from 'three';
 import { writable, get } from 'svelte/store';
 import { objectsGroup, globalScene, globalRenderer } from '../stores/sceneStore';
 import { safeStorage } from './safeStorage';
+import { qualityOverrides } from './qualityGovernor';
 
 // Light parameter registry (phase 79): type-specific settings the Inspector
 // renders (color/intensity/visible are common rows it already has). Values
@@ -51,8 +52,19 @@ export function cappedShadowSize(wanted) {
 /** re-apply the cap to every shadow-casting light (on quality change) —
  * walks both objectsGroup and the scene-root environment rig, and toggles the
  * renderer's shadow map on the 'off' setting */
+/**
+ * Are shadows off on THIS device right now: the user's saved 'off', or 26-D's quality
+ * governor holding its shadows step (a local override that never writes the preference).
+ * The ONE read every place that sets `renderer.shadowMap.enabled` must use — the first
+ * version of the override was undone within a frame by environment.applyEnvironment, which
+ * re-asserted the saved preference on every apply.
+ */
+export function shadowsDisabled() {
+	return get(shadowQuality) === 'off' || get(qualityOverrides).shadowsOff;
+}
+
 export function applyShadowQualityCap() {
-	const off = get(shadowQuality) === 'off';
+	const off = shadowsDisabled();
 	/** @type {any} */
 	const renderer = get(globalRenderer);
 	if (renderer?.shadowMap) {
@@ -131,4 +143,10 @@ export function startLightParams() {
 		safeStorage.setItem('shadowQuality', String(value));
 		applyShadowQualityCap();
 	});
+	let lastShadowsOff = false;
+	qualityOverrides.subscribe((o) => {
+		if (o.shadowsOff === lastShadowsOff) return;
+		lastShadowsOff = o.shadowsOff;
+		applyShadowQualityCap();
+	});
 }
diff --git a/src/lib/overloadGuard.js b/src/lib/overloadGuard.js
index e226a3cf..fdebf0ee 100644
--- a/src/lib/overloadGuard.js
+++ b/src/lib/overloadGuard.js
@@ -1,6 +1,6 @@
 import { writable, get } from 'svelte/store';
 import { objectsGroup, globalRenderer, pokeScene } from '../stores/sceneStore';
-import { BUDGETS, profileFor, registerFrameObserver, sceneMetrics, tierOf } from './sceneBudget';
+import { BUDGETS, profileFor, registerFrameObserver, sceneMetrics, isHeavy, qualityBaseline } from './sceneBudget';
 
 // 26-G (roadmap 26 section 4, Stages 3 and 4) — WHEN THE SCENE IS TOO HEAVY TO RUN.
 //
@@ -119,19 +119,16 @@ export function noteFrameForFreeze(ms) {
 	return false;
 }
 
-/** The scene-size axes only — never frame time itself, which would make the rule
- * circular. `unknown` (nothing sampled yet) is NOT heavy, so a freshly booted page can
- * never be paused before the first reading. */
-const HEAVY_AXES = ['objects', 'triangles', 'calls'];
-
-/** Is the scene big enough that pausing it and setting part of it aside could help? */
+/** Is the scene big enough that pausing it and setting part of it aside could help?
+ * The size axes only (`sceneBudget.HEAVY_AXES`); `unknown` (nothing sampled yet) is NOT
+ * heavy, so a freshly booted page can never be paused before the first reading.
+ * 26-D: judged against what the scene cost BEFORE the quality governor reduced it
+ * (`qualityBaseline`) — the governor drawing less must not talk this guard out of a
+ * scene that is still too heavy. */
 export function sceneIsHeavy() {
 	const metrics = get(sceneMetrics);
 	const profile = metrics?.profile === 'vr' ? 'vr' : 'desktop';
-	return HEAVY_AXES.some((key) => {
-		const tier = tierOf(key, metrics?.[key], profile);
-		return tier === 'amber' || tier === 'red';
-	});
+	return isHeavy(metrics, profile, get(qualityBaseline));
 }
 
 /** @param {string} reason */
diff --git a/src/lib/particleRuntime.js b/src/lib/particleRuntime.js
index 918df55c..14de142b 100644
--- a/src/lib/particleRuntime.js
+++ b/src/lib/particleRuntime.js
@@ -6,6 +6,12 @@ import { showToast } from '../stores/appStore';
 import { wireframeActive } from './viewMode';
 import { particleVertexShader, particleFragmentShader, spriteTexture, wrapTime } from './particleShader';
 import { PARTICLE_DEFAULTS } from './particlePresets';
+import { qualityOverrides } from './qualityGovernor';
+
+// 26-D: the governor's particle step caps every emitter at the VR count (roadmap 26 Stage 3's
+// third bullet). Read through a subscription — this runs per frame per emitter.
+let particlesCapped = false;
+qualityOverrides.subscribe((o) => (particlesCapped = o.particlesCapped));
 
 // Particle emitter runtime (PFX-A). flowRuntime hands over the live emitters
 // each tick — `particle` NODE pairs (like sound) plus every object carrying
@@ -263,7 +269,7 @@ export function updateParticles(pairs, sceneObjects, time) {
 	const camera = get(globalCamera);
 	const height = renderer?.domElement?.height ?? 600;
 	const sizeScale = height / (2 * Math.tan(((camera?.fov ?? 40) * Math.PI) / 360));
-	const vr = get(isVRMode);
+	const vr = get(isVRMode) || particlesCapped;
 	const tw = wrapTime(time);
 
 	const wanted = new Set();
diff --git a/src/lib/physics.js b/src/lib/physics.js
index cc27ca41..9ef86c34 100644
--- a/src/lib/physics.js
+++ b/src/lib/physics.js
@@ -1,6 +1,7 @@
 import * as THREE from 'three';
 // 26-G: the streak watch is a pure leaf (stores + sceneBudget) — no edge into history.
 import { createStreakWatch, PHYSICS_SLOW_MS, PHYSICS_SLOW_STEPS } from './overloadGuard';
+import { registerMetricSource } from './sceneBudget';
 import { writable, get } from 'svelte/store';
 import { flowGraphs, allNodes, allEdges, SCENE_GRAPH } from '../stores/flowStore';
 import { objectsGroup, lockedObjects, selectedObject, selectedObjects, pokeScene } from '../stores/sceneStore';
@@ -826,6 +827,7 @@ async function startSimulation() {
 	// ColliderDesc.trimesh (fixed bodies only) and terrain from a heightfield —
 	// both deferred; every collider today is a cuboid AABB or an opt-in hull.
 	bodies = [];
+	stepTimes = []; // 26-E: a new run's cost is not the last run's
 	beforeStates = [];
 	suspendedForRun = [];
 	fixedBodies = new Map();
@@ -1255,6 +1257,7 @@ function step(now) {
 	try {
 		const started = performance.now();
 		stepInner(now);
+		noteStepMs(performance.now() - started);
 		// 26-G (roadmap 26 Stage 3): A SIMULATION THAT CANNOT KEEP UP. 27-C catches a step
 		// that THROWS; nothing caught one that simply takes longer than the frame it runs
 		// in, which turns every frame late before rendering starts and reads as the app
@@ -1277,6 +1280,33 @@ function step(now) {
 
 const slowStepWatch = createStreakWatch({ overMs: PHYSICS_SLOW_MS, count: PHYSICS_SLOW_STEPS });
 
+// 26-E: what a simulation COSTS, for the budget sampler and the stress rig. Roadmap 26
+// section 2 budgets dynamic bodies (<200 desktop) and section 3 names the step time;
+// neither was readable anywhere. Registered, never imported — sceneBudget is a leaf and
+// physics sits in the history family. A step ring rather than the last value, because
+// the question is the same as for frames: the step you FEEL is the slow one.
+const STEP_RING = 120;
+/** @type {number[]} */
+let stepTimes = [];
+/** @param {number} ms */
+function noteStepMs(ms) {
+	stepTimes.push(ms);
+	if (stepTimes.length > STEP_RING) stepTimes.shift();
+}
+/** p95 of the recent steps, or null when no simulation is running (a stale ring from a
+ * run that ended must not read as a live cost). */
+export function physicsStepStats() {
+	if (!world || !stepTimes.length) return null;
+	const sorted = [...stepTimes].sort((a, b) => a - b);
+	const at = (/** @type {number} */ q) => sorted[Math.min(sorted.length - 1, Math.max(0, Math.ceil(q * sorted.length) - 1))];
+	return { n: sorted.length, p50: at(0.5), p95: at(0.95), max: sorted[sorted.length - 1] };
+}
+registerMetricSource('bodies', () => (world ? bodies.length : 0));
+registerMetricSource('physicsStepMs', () => {
+	const stats = physicsStepStats();
+	return stats ? Math.round(stats.p95 * 100) / 100 : null;
+});
+
 /** ONE stop path for the slow-step streak, shared by the real step and the test hook so
  * the two cannot drift apart. */
 function stopForSlowSteps() {
diff --git a/src/lib/qualityGovernor.js b/src/lib/qualityGovernor.js
new file mode 100644
index 00000000..f70913cc
--- /dev/null
+++ b/src/lib/qualityGovernor.js
@@ -0,0 +1,242 @@
+import { writable, get } from 'svelte/store';
+import {
+	createGovernor,
+	overridesAt,
+	stepLabelsAt,
+	drawGapFor,
+	FULL_QUALITY,
+	MAX_LEVEL
+} from './qualityGovernorCore';
+import {
+	registerFrameObserver,
+	registerLongTaskObserver,
+	sceneMetrics,
+	isHeavy,
+	qualityBaseline
+} from './sceneBudget';
+import { renderPaused } from './overloadGuard';
+import { sceneBatchOpen } from '../stores/sceneStore';
+import { safeStorage } from './safeStorage';
+
+// 26-D (roadmap 26 section 4, Stage 1) — ADAPTIVE QUALITY: THE WIRING.
+//
+// The RULE is `qualityGovernorCore.js` (pure, unit-tested); this file feeds it the frames
+// sceneBudget's loop already measures, publishes what it decided, and holds the two
+// things a person can say about it (pin it, give it back). Every consumer READS a store —
+// lightParams (shadows), Outline (AO, the post stack, the composer size, the ingest draw
+// gap), Scene (the pixel ratio, the presence send gap), particleRuntime (the particle cap)
+// — so this module imports none of them and stays a leaf beside overloadGuard.
+//
+// NOTHING HERE PERSISTS OR REPLICATES except the one opt-out, `autoQuality`: a level is a
+// fact about this device right now. In particular a reduced shadow setting is NEVER written
+// to `shadowQuality` — that is the user's preference, saved to storage, and a governor that
+// wrote it would leave a person with shadows off forever after one heavy scene.
+//
+// WHAT IT MUST NOT DO: fight 26-G. The freeze streak only counts while the scene is heavy,
+// and turning shadows off halves the draw calls, which would make the scene read as light.
+// So the first step records the size readings as they were (`qualityBaseline`) and 26-G
+// judges against those until the governor is back at full quality. The perf-governor
+// suite proves it: a heavy scene reduced to green calls still pauses on a frozen streak.
+//
+// VR: sceneBudget's loop is window rAF, which does not run inside an immersive session, so
+// the governor sees no frames in a headset and never acts there. The VR thresholds are
+// carried in the core for when it does — owed on a headset.
+
+/** @typedef {import('./qualityGovernorCore').QualityOverrides} QualityOverrides */
+
+/** What every consumer reads. LOCAL, never saved, never sent.
+ * @type {import('svelte/store').Writable<QualityOverrides>} */
+export const qualityOverrides = writable({ ...FULL_QUALITY });
+
+/** The ingest draw gap in ms (0 = draw every frame). Its own store because it changes on a
+ * different clock from a quality level: it lasts exactly as long as one received batch. */
+export const ingestDrawGap = writable(0);
+
+/**
+ * For the chip and the suite.
+ * @type {import('svelte/store').Writable<{level: number, max: number, pinned: boolean, labels: string[], reason: string, at: number, snoozedUntil: number}>}
+ */
+export const qualityState = writable({
+	level: 0,
+	max: MAX_LEVEL,
+	pinned: false,
+	labels: /** @type {string[]} */ ([]),
+	reason: '',
+	at: 0,
+	snoozedUntil: 0
+});
+
+/** The opt-out. LOCAL preference, default ON. */
+export const autoQuality = writable(safeStorage.getItem('autoQuality') !== 'false');
+
+/** A decision is taken at most this often; the frames themselves are noted every frame. */
+const DECIDE_EVERY_MS = 250;
+/** "Restore full quality" means it: no automatic step for this long afterwards. */
+export const RELEASE_SNOOZE_MS = 60000;
+
+const governor = createGovernor();
+let lastDecideAt = 0;
+let wasHidden = false;
+let pinned = false;
+let snoozedUntil = 0;
+let drawGapEngaged = false;
+/** @type {string} */
+let lastReason = '';
+
+function now() {
+	return typeof performance !== 'undefined' ? performance.now() : Date.now();
+}
+
+/** @param {number} level @param {string} reason */
+function publish(level, reason) {
+	const at = Date.now();
+	if (level > 0 && !get(qualityBaseline)) {
+		// the FIRST step: remember what the scene cost at full quality (see the header)
+		const m = get(sceneMetrics);
+		qualityBaseline.set({
+			objects: Number(m.objects) || 0,
+			triangles: Number(m.triangles) || 0,
+			calls: Number(m.calls) || 0
+		});
+	}
+	if (level === 0) qualityBaseline.set(null);
+	qualityOverrides.set(overridesAt(level));
+	lastReason = reason;
+	qualityState.set({
+		level,
+		max: MAX_LEVEL,
+		pinned,
+		labels: stepLabelsAt(level),
+		reason,
+		at,
+		snoozedUntil
+	});
+}
+
+/** The profile and heaviness the core needs, read off the last sample. */
+function context() {
+	const metrics = get(sceneMetrics);
+	const profile = metrics?.profile === 'vr' ? 'vr' : 'desktop';
+	return { metrics, profile: /** @type {'desktop'|'vr'} */ (profile), heavy: isHeavy(metrics, profile, get(qualityBaseline)) };
+}
+
+/**
+ * Fed every frame by sceneBudget's loop.
+ * @param {number} ms
+ */
+export function noteFrameForQuality(ms) {
+	const t = now();
+	// a hidden tab is throttled to ~1Hz on purpose and its first frame back spans the
+	// whole absence; neither is the scene being slow (26-G's rule, same reasons)
+	if (typeof document !== 'undefined' && document.visibilityState !== 'visible') {
+		wasHidden = true;
+		governor.forget();
+		return;
+	}
+	if (wasHidden) {
+		wasHidden = false;
+		governor.forget();
+		return;
+	}
+	// paused by 26-G: no frames are being drawn, so none of these describe drawing
+	if (get(renderPaused)) {
+		governor.forget();
+		return;
+	}
+	governor.noteFrame(ms, t);
+	if (t - lastDecideAt < DECIDE_EVERY_MS) return;
+	lastDecideAt = t;
+	decideNow(t);
+}
+
+/** One decision, now. Exported for the suite, which drives time it cannot wait out.
+ * @param {number} [t] */
+export function decideNow(t = now()) {
+	const ctx = context();
+	const enabled = get(autoQuality);
+	// "Restore full quality" snoozes CLIMBING for a minute; it never blocks a walk back down
+	const snoozed = Date.now() < snoozedUntil;
+	const d = enabled
+		? governor.decide(t, { profile: ctx.profile, heavy: ctx.heavy && !snoozed, pinned })
+		: { level: governor.level(), moved: null, reason: 'off', p95: null };
+	if (d.moved) publish(d.level, d.reason);
+
+	// THE INGEST RULE (26-E): while a received batch drains through slow frames, draw at
+	// most four frames a second so the queue gets the main thread back
+	const draining = sceneBatchOpen();
+	const backlog = Number(ctx.metrics?.ingestBacklog) || 0;
+	const gap = enabled ? drawGapFor({ engaged: drawGapEngaged, draining, backlog, p95: d.p95, profile: ctx.profile }) : 0;
+	drawGapEngaged = gap > 0;
+	if (get(ingestDrawGap) !== gap) ingestDrawGap.set(gap);
+	return d;
+}
+
+/** Keep the current level: no walking back up until released. */
+export function pinQuality() {
+	pinned = true;
+	publish(governor.level(), lastReason || 'pinned');
+}
+
+/** Full quality now, and no automatic step for a minute — "give it back" must stick long
+ * enough to see what it looks like. */
+export function releaseQuality() {
+	pinned = false;
+	snoozedUntil = Date.now() + RELEASE_SNOOZE_MS;
+	governor.setLevel(0, now());
+	publish(0, 'released');
+}
+
+/** @param {boolean} on */
+export function setAutoQuality(on) {
+	autoQuality.set(!!on);
+}
+
+// ONE path for the opt-out, whoever flips it (Settings binds the store, the suite calls
+// setAutoQuality): remember it locally, and turning it off gives full quality back NOW
+let autoQualitySeen = false;
+autoQuality.subscribe((on) => {
+	// the first call is the value just read from storage — nothing to write or undo
+	if (!autoQualitySeen) {
+		autoQualitySeen = true;
+		return;
+	}
+	safeStorage.setItem('autoQuality', on ? 'true' : 'false');
+	if (!on) {
+		pinned = false;
+		governor.setLevel(0, now());
+		publish(0, 'turned off');
+		ingestDrawGap.set(0);
+		drawGapEngaged = false;
+	}
+});
+
+/** TEST-ONLY: feed a synthetic frame / long task at an explicit time, and reset. */
+export const governorForTest = {
+	/** @param {number} ms @param {number} t */
+	frame(ms, t) {
+		governor.noteFrame(ms, t);
+	},
+	/** @param {number} t */
+	longTask(t) {
+		governor.noteLongTask(t);
+	},
+	/** @param {number} level */
+	setLevel(level) {
+		governor.setLevel(level, now());
+		publish(governor.level(), 'test');
+	},
+	reset() {
+		pinned = false;
+		snoozedUntil = 0;
+		drawGapEngaged = false;
+		lastDecideAt = 0;
+		governor.setLevel(0, -1e9);
+		governor.forget();
+		ingestDrawGap.set(0);
+		publish(0, 'reset');
+	},
+	level: () => governor.level()
+};
+
+registerFrameObserver(noteFrameForQuality);
+registerLongTaskObserver(() => governor.noteLongTask(now()));
diff --git a/src/lib/qualityGovernorCore.js b/src/lib/qualityGovernorCore.js
new file mode 100644
index 00000000..2450520d
--- /dev/null
+++ b/src/lib/qualityGovernorCore.js
@@ -0,0 +1,265 @@
+// 26-D (roadmap 26 section 4, Stage 1) — THE ADAPTIVE QUALITY GOVERNOR'S DECISION RULE.
+//
+// PURE and import-free: frame times and long-task moments go in, a level comes out. The
+// wiring (which store a level writes, which frame loop feeds it, what the chip says) is
+// `qualityGovernor.js`; this file is only the rule, so every threshold and every hold is
+// provable with no GPU, no browser and no clock (vitest drives it with invented times).
+//
+// WHAT 26-E MEASURED, AND WHAT THE STEP ORDER TAKES FROM IT (Radeon 890M, 1280x720):
+//   - a many-object scene is bound by DRAW CALLS — CPU time per call — and the shadow pass
+//     draws every mesh a second time: 1,000 boxes = 1,943 calls, 3,000 = 5,323 (p95 50ms).
+//     Turning the post stack off moved nothing (shaded: 5,236 calls, p95 49.9).
+//   - a dense scene (6M triangles) held 60fps on the same GPU, so resolution is the lever
+//     only where FILL is the cost — a weaker GPU, a HiDPI screen.
+//   - the biggest freeze was not drawing a scene but RECEIVING one: ingest is frame-bound,
+//     3,000 objects took ~180s to land while the joiner drew them and 5.6s with drawing
+//     paused. That is its own rule below (`drawGapFor`), not a quality step.
+// So the order is SHADOWS first (halves the calls where the cost is), then resolution in
+// the roadmap's 0.85 steps, then AO and the rest of the post stack, then particles and the
+// presence stream. The roadmap listed resolution first; the measurement is why it is not.
+//
+// Every step is REVERSIBLE and LOCAL — nothing here writes a preference, a document or a
+// message. A level is a fact about this device right now.
+
+/** @typedef {{dprScale: number, shadowsOff: boolean, aoOff: boolean, postOff: boolean, particlesCapped: boolean, presenceSlow: boolean}} QualityOverrides */
+
+/** @type {QualityOverrides} */
+export const FULL_QUALITY = Object.freeze({
+	dprScale: 1,
+	shadowsOff: false,
+	aoOff: false,
+	postOff: false,
+	particlesCapped: false,
+	presenceSlow: false
+});
+
+/**
+ * The steps, in the order they are taken. Each names only what it changes; a level is the
+ * sum of every step up to it (a later `dprScale` replaces an earlier one).
+ * @type {{key: string, label: string, set: Partial<QualityOverrides>}[]}
+ */
+export const GOVERNOR_STEPS = [
+	{ key: 'shadows', label: 'Shadows off', set: { shadowsOff: true } },
+	{ key: 'res85', label: 'Resolution 85%', set: { dprScale: 0.85 } },
+	{ key: 'res72', label: 'Resolution 72%', set: { dprScale: 0.72 } },
+	{ key: 'ao', label: 'Ambient occlusion off', set: { aoOff: true } },
+	{ key: 'res61', label: 'Resolution 61%', set: { dprScale: 0.61 } },
+	{ key: 'post', label: 'Scene look (post-processing) off', set: { postOff: true } },
+	{ key: 'res50', label: 'Resolution 50%', set: { dprScale: 0.5 } },
+	{ key: 'particles', label: 'Fewer particles', set: { particlesCapped: true } },
+	{ key: 'presence', label: 'Your camera updates to peers halved', set: { presenceSlow: true } }
+];
+
+export const MAX_LEVEL = GOVERNOR_STEPS.length;
+
+/** @param {number} level @returns {QualityOverrides} */
+export function overridesAt(level) {
+	/** @type {QualityOverrides} */
+	const out = { ...FULL_QUALITY };
+	const n = Math.max(0, Math.min(MAX_LEVEL, Math.floor(level) || 0));
+	for (let i = 0; i < n; i++) Object.assign(out, GOVERNOR_STEPS[i].set);
+	return out;
+}
+
+/** The labels of every step in effect at `level`, for the chip's tooltip. @param {number} level */
+export function stepLabelsAt(level) {
+	return GOVERNOR_STEPS.slice(0, Math.max(0, Math.min(MAX_LEVEL, level))).map((s) => s.label);
+}
+
+/**
+ * Thresholds per profile. Desktop: slower than 30fps, and recovery under 20ms. The roadmap
+ * said "p95 > 33ms"; 26-E measured why that cannot be the number — frames are VSYNC-
+ * QUANTISED, so a scene holding a steady 30fps reads 33.3-33.4ms at every percentile, and a
+ * 33ms trigger would call it overloaded and keep stepping to the bottom of the ladder. 35ms
+ * is the first reading that means a 30fps frame was actually missed. VR: 72Hz (13.9ms) and
+ * recovery at 90Hz (11.1ms) — the roadmap's, UNMEASURED: the governor's frame source does not
+ * run inside an XR session yet, so they are carried for when it does (owed on a headset).
+ */
+export const THRESHOLDS = {
+	desktop: { overMs: 35, underMs: 20 },
+	vr: { overMs: 13.9, underMs: 11.1 }
+};
+
+export const TIMING = {
+	/** p95 over this much recent time decides "overloaded" */
+	triggerWindowMs: 2000,
+	/** a step is held at least this long before the next one (the roadmap's 3s) */
+	stepHoldMs: 3000,
+	/** recovery needs this much consecutive good time (the roadmap's 10s) */
+	recoverWindowMs: 10000,
+	/** long tasks counted over this window… */
+	longTaskWindowMs: 5000,
+	/** …more than this many is overloaded, whatever the frames say */
+	longTasksOver: 2,
+	/** a step back UP within this long after a walk back DOWN doubles the next recovery */
+	flapWindowMs: 20000,
+	/** the recovery hold never grows past this */
+	maxRecoverHoldMs: 80000,
+	/** a window must be at least this full before it may decide anything */
+	coverage: 0.75,
+	/** frames this soon after a change are not evidence: the change itself costs a hitch
+	 * (turning shadows off recompiles every lit material, a dpr change reallocates the
+	 * composer). MEASURED: without this, 3,000 real boxes took a second, needless step
+	 * on the recompile frames right after the shadows step. */
+	settleMs: 600
+};
+
+/** Nearest-rank percentile (sceneBudget's rule). @param {number[]} sorted @param {number} q */
+function percentile(sorted, q) {
+	if (!sorted.length) return null;
+	return sorted[Math.min(sorted.length - 1, Math.max(0, Math.ceil(q * sorted.length) - 1))];
+}
+
+/**
+ * One governor. `note*` feed it; `decide` says whether the level moves.
+ *
+ * HOLD, NOT HURRY: a decision is only ever taken on a FULL window, and every level change
+ * throws the window away — the frames that justified the last step describe a scene that
+ * no longer exists. So a step is followed by at least `stepHoldMs` of fresh frames before
+ * the next, and a walk back down by `recoverWindowMs` of them.
+ *
+ * FLAPPING is the failure mode of every automatic quality system (drop, recover, drop…,
+ * each transition itself a visible hitch). A step back up shortly after a walk down
+ * doubles the recovery hold for next time, capped; a step up long after the last walk down
+ * is just a heavier scene, and resets it.
+ * @param {{timing?: Partial<typeof TIMING>}} [opts]
+ */
+export function createGovernor(opts = {}) {
+	const timing = { ...TIMING, ...(opts.timing ?? {}) };
+	/** @type {{at: number, ms: number}[]} */
+	let frames = [];
+	/** @type {number[]} */
+	let longTasks = [];
+	let level = 0;
+	let changedAt = -Infinity;
+	let lastDownAt = -Infinity;
+	let recoverHoldMs = timing.recoverWindowMs;
+	let settleUntil = -Infinity;
+
+	function trim(/** @type {number} */ now) {
+		// keep enough for the LONGEST window any decision reads — the recovery hold grows
+		// when the governor flaps, and a ring trimmed shorter than it could never recover
+		const keep = Math.max(recoverHoldMs, timing.triggerWindowMs);
+		if (frames.length && frames[0].at < now - keep) frames = frames.filter((f) => f.at >= now - keep);
+		if (longTasks.length && longTasks[0] < now - timing.longTaskWindowMs)
+			longTasks = longTasks.filter((t) => t >= now - timing.longTaskWindowMs);
+	}
+
+	/** p95 over the last `windowMs`, or null when the window is not full enough to judge */
+	function p95Over(/** @type {number} */ now, /** @type {number} */ windowMs) {
+		const from = now - windowMs;
+		const inWindow = frames.filter((f) => f.at >= from);
+		if (inWindow.length < 8) return null;
+		// covered: the oldest sample reaches back far enough, and nothing older than the
+		// last change can be in here (the window was emptied then)
+		if (inWindow[0].at - inWindow[0].ms > from + windowMs * (1 - timing.coverage)) return null;
+		return percentile(inWindow.map((f) => f.ms).sort((a, b) => a - b), 0.95);
+	}
+
+	function change(/** @type {number} */ to, /** @type {number} */ now) {
+		if (to < level) lastDownAt = now;
+		else if (to > level)
+			// a step up soon after a walk down is a FLAP: make the next recovery wait longer.
+			// A step up long after one is simply a scene that got heavier: forgive the history
+			recoverHoldMs =
+				now - lastDownAt < timing.flapWindowMs
+					? Math.min(timing.maxRecoverHoldMs, recoverHoldMs * 2)
+					: timing.recoverWindowMs;
+		level = to;
+		changedAt = now;
+		settleUntil = now + timing.settleMs;
+		frames = [];
+		longTasks = [];
+	}
+
+	return {
+		/** @param {number} ms @param {number} now */
+		noteFrame(ms, now) {
+			if (!Number.isFinite(ms) || ms <= 0) return;
+			if (now < settleUntil) return;
+			frames.push({ at: now, ms });
+			trim(now);
+		},
+		/** @param {number} now */
+		noteLongTask(now) {
+			if (now < settleUntil) return;
+			longTasks.push(now);
+			trim(now);
+		},
+		/** Throw the evidence away — a hidden tab, a pause, a resume. The next decision waits
+		 * for a full window of frames that describe the present. */
+		forget() {
+			frames = [];
+			longTasks = [];
+		},
+		/**
+		 * @param {number} now
+		 * @param {{profile?: 'desktop'|'vr', heavy: boolean, pinned?: boolean}} ctx
+		 * @returns {{level: number, moved: 'up'|'down'|null, reason: string, p95: number|null}}
+		 */
+		decide(now, ctx) {
+			trim(now);
+			const t = THRESHOLDS[ctx.profile === 'vr' ? 'vr' : 'desktop'];
+			const p95 = p95Over(now, timing.triggerWindowMs);
+			const tasks = longTasks.filter((at) => at >= now - timing.longTaskWindowMs).length;
+			const overloaded = (p95 != null && p95 > t.overMs) || tasks > timing.longTasksOver;
+			const since = now - changedAt;
+
+			// UP: overloaded, the scene is heavy enough that setting quality aside could help,
+			// and the last step has had its hold
+			if (overloaded && ctx.heavy && level < MAX_LEVEL && since >= timing.stepHoldMs) {
+				change(level + 1, now);
+				return { level, moved: 'up', reason: p95 != null && p95 > t.overMs ? 'frames' : 'long tasks', p95 };
+			}
+			if (level > 0 && !ctx.pinned && since >= recoverHoldMs) {
+				// the scene is no longer heavy: a light scene is never governed, so give it back
+				if (!ctx.heavy) {
+					change(level - 1, now);
+					return { level, moved: 'down', reason: 'scene is light', p95 };
+				}
+				const calm = p95Over(now, recoverHoldMs);
+				if (calm != null && calm < t.underMs && tasks === 0) {
+					change(level - 1, now);
+					return { level, moved: 'down', reason: 'recovered', p95: calm };
+				}
+			}
+			return { level, moved: null, reason: overloaded ? 'overloaded' : 'steady', p95 };
+		},
+		/** Set the level directly (the chip's "restore full quality"). @param {number} to @param {number} now */
+		setLevel(to, now) {
+			const next = Math.max(0, Math.min(MAX_LEVEL, Math.floor(to) || 0));
+			if (next !== level) change(next, now);
+			return level;
+		},
+		level: () => level,
+		recoverHoldMs: () => recoverHoldMs
+	};
+}
+
+/**
+ * THE INGEST RULE (26-E's biggest finding). While a received scene is still draining into
+ * this one, a slow frame is not only a slow frame — it is the drain's throughput, because
+ * every object's parse waits for a frame to pass. So while a batch drains AND drawing is
+ * slow, draw at most one frame every `INGEST_DRAW_GAP_MS`: the scene keeps visibly
+ * filling in, and the queue gets the main thread back. Returns the gap to enforce, or 0.
+ *
+ * STICKY FOR THE DRAIN: once throttled, the frames are cheap BECAUSE they are throttled, so
+ * re-judging on them would switch the throttle off, which makes them slow, which switches
+ * it on — a flicker at the period of the frame window. It is engaged once per drain and
+ * released when the drain ends. Not a level: it ends by itself, so it stays off the chip.
+ * @param {{engaged: boolean, draining: boolean, backlog: number, p95: number|null, profile?: 'desktop'|'vr'}} ctx
+ */
+export function drawGapFor(ctx) {
+	if (!ctx.draining) return 0;
+	if (ctx.engaged) return INGEST_DRAW_GAP_MS;
+	if (!(ctx.backlog > INGEST_MIN_BACKLOG)) return 0;
+	const t = THRESHOLDS[ctx.profile === 'vr' ? 'vr' : 'desktop'];
+	// a fast frame costs the drain nothing worth saving — only a slow one is throttled
+	if (ctx.p95 == null || ctx.p95 <= t.underMs) return 0;
+	return INGEST_DRAW_GAP_MS;
+}
+
+/** Below this many parked objects a drain finishes in well under a second anyway. */
+export const INGEST_MIN_BACKLOG = 50;
+/** Four frames a second while a big scene lands: enough to see it arrive. */
+export const INGEST_DRAW_GAP_MS = 250;
diff --git a/src/lib/sceneBudget.js b/src/lib/sceneBudget.js
index cc446420..bf2adaea 100644
--- a/src/lib/sceneBudget.js
+++ b/src/lib/sceneBudget.js
@@ -46,11 +46,18 @@ export const BUDGETS = [
 		vr: [500, 1500],
 		why: 'every object is at least one draw call, one wire message per joiner, one row in the tree and one node in every traversal'
 	},
+	// 26-E MEASURED the two render axes below (tests/e2e/scene-stress.cjs, Radeon 890M
+	// iGPU, 1280x720): they are counted per DISPLAY frame across every render() call now,
+	// which the starting numbers never were — a frame is ~13 calls with the composer, and
+	// the shadow pass draws each mesh again, so both read about TWICE the naive count.
+	// VR/mobile columns are still the starting estimates; they are owed on a headset.
 	{
 		key: 'triangles',
 		label: 'Triangles / frame',
 		unit: '',
-		desktop: [1000000, 3000000],
+		// 6.0M/frame (15 x 200k-tri models, shadow pass included) held a locked 60fps on
+		// an integrated GPU; the red edge above that is extrapolated, not measured
+		desktop: [4000000, 8000000],
 		vr: [300000, 600000],
 		why: 'vertex and fill cost, at 60Hz on a desktop against 72-90Hz on a headset'
 	},
@@ -58,7 +65,10 @@ export const BUDGETS = [
 		key: 'calls',
 		label: 'Draw calls / frame',
 		unit: '',
-		desktop: [1000, 2000],
+		// measured: 1,943 calls (1,000 boxes) 60fps p95 16.7 · 2,799-3,625 p95 33 ·
+		// 4,446 a steady 30fps · 5,323 p95 50 · 16,342 p95 133. Calls, not triangles, are
+		// what binds a many-object scene: it is CPU time per call
+		desktop: [2000, 4500],
 		vr: [300, 500],
 		why: 'there is no instancing or batching in core, so every call is CPU time'
 	},
@@ -196,6 +206,45 @@ export function ingestVerdict(current, incoming, profile) {
 	};
 }
 
+// --- is the scene heavy? (26-G's gate, 26-D's gate) --------------------------------
+
+/** The scene-size axes only — never frame time itself, which would make the rule
+ * circular: "slow, therefore heavy, therefore act on the slowness". */
+export const HEAVY_AXES = ['objects', 'triangles', 'calls'];
+
+/**
+ * The size readings as they were BEFORE the quality governor (26-D) took anything away,
+ * or null while nothing is reduced. LOCAL.
+ *
+ * WHY IT EXISTS: turning shadows off halves the draw calls (26-E measured the shadow pass
+ * as the second copy of every mesh). A heaviness rule reading the live calls would then
+ * see a lighter scene, so 26-G's freeze streak — which only counts while the scene is
+ * heavy — would stand down BECAUSE the governor helped, and the one scene that most needs
+ * the last-resort pause could no longer get it. The scene did not get lighter; this
+ * device drew less of it.
+ * @type {import('svelte/store').Writable<{objects: number, triangles: number, calls: number} | null>}
+ */
+export const qualityBaseline = writable(null);
+
+/**
+ * Heavy = any size axis at amber or worse. While a baseline stands, each axis reads the
+ * larger of now and then — unless the scene really did shrink (fewer than 70% of the
+ * objects the baseline was taken with), in which case the baseline no longer describes
+ * this scene and is ignored. PURE.
+ * @param {Record<string, any>} metrics @param {'desktop'|'vr'} profile
+ * @param {{objects: number, triangles: number, calls: number} | null} [baseline]
+ */
+export function isHeavy(metrics, profile, baseline = null) {
+	const valid = !!baseline && Number(metrics?.objects) >= 0.7 * Number(baseline.objects);
+	return HEAVY_AXES.some((key) => {
+		const now = metrics?.[key];
+		const then = valid ? /** @type {any} */ (baseline)[key] : null;
+		const reading = Number.isFinite(then) && (!Number.isFinite(now) || then > now) ? then : now;
+		const tier = tierOf(key, reading, profile);
+		return tier === 'amber' || tier === 'red';
+	});
+}
+
 // --- frame times ------------------------------------------------------------------
 // A RING, not an average. p95 is the whole point: a scene that renders 58 of every 60
 // frames in 8ms and two in 300ms reads as 60fps and feels broken.
@@ -238,9 +287,30 @@ let longTasks = [];
 /** @type {any} */
 let longTaskObserver = null;
 
+/** @type {Set<(ms: number) => void>} */
+const longTaskObservers = new Set();
+
+/**
+ * Hear every long task as it is observed. 26-D's governor is the reader (more than two
+ * in five seconds is "overloaded" whatever the frames say); registered, never imported,
+ * for the same reason as `registerFrameObserver`.
+ * @param {(ms: number) => void} fn @returns {() => void} unregister
+ */
+export function registerLongTaskObserver(fn) {
+	longTaskObservers.add(fn);
+	return () => longTaskObservers.delete(fn);
+}
+
 /** @param {number} ms */
 export function noteLongTask(ms) {
 	const now = Date.now();
+	for (const fn of longTaskObservers) {
+		try {
+			fn(ms);
+		} catch {
+			/* isolated — one bad observer must not end the observation */
+		}
+	}
 	longTasks.push({ at: now, ms });
 	// a rolling minute, which is what the budget is stated in
 	longTasks = longTasks.filter((t) => now - t.at < 60000);
@@ -377,10 +447,89 @@ function walkScene() {
 	return { objects, meshes, hidden };
 }
 
+// --- per-frame render totals (26-E) -----------------------------------------------
+//
+// THE FINDING the stress rig made on its first run: 1,000 boxes on screen, and the meter
+// read `triangles: 1, calls: 1`. `renderer.info` is AUTO-RESET at the start of every
+// `renderer.render()` call, and a desktop frame is not one call — the EffectComposer
+// renders the scene into a target, then N8AO, then the outline, then a fullscreen
+// triangle to the canvas, each its own `render()`. Whatever reads `info` afterwards sees
+// the LAST pass: one triangle, one call. So the triangle and draw-call budgets could
+// never leave green, and 26-G's `sceneIsHeavy` was really asking about objects alone.
+//
+// The fix counts EVERY `render()` and divides by the display frames the sampler saw.
+// Deliberately NOT `info.autoReset = false`: that changes what `info` means for every
+// other reader (the VR stats plate, the diagnostics section, a test that resets and
+// renders once), and inside a WebXR session `window.requestAnimationFrame` does not run,
+// so nothing would ever reset it again and the plate would count up forever. A wrapper
+// on the instance leaves `info` byte-identical for everyone and works in XR too.
+
+const renderAcc = { calls: 0, triangles: 0, renders: 0 };
+/** Display frames the sampler loop counted since the last sample. */
+let renderFrames = 0;
+
+/**
+ * Wrap this renderer's `render` so each call adds what it drew to the accumulator. Once
+ * per instance (a restored context can hand the store a NEW renderer, which gets its own).
+ * @param {any} renderer
+ */
+export function countRenderCalls(renderer) {
+	if (!renderer || typeof renderer.render !== 'function' || renderer.__budgetRender) return false;
+	const original = renderer.render;
+	renderer.__budgetRender = original;
+	renderer.render = function (/** @type {any[]} */ ...args) {
+		const info = this.info?.render;
+		// with autoReset ON (three's default) render() zeroes the counters itself, so the
+		// base is 0; with it OFF somebody is accumulating on purpose and we take the delta
+		const baseCalls = info && this.info.autoReset === false ? info.calls : 0;
+		const baseTris = info && this.info.autoReset === false ? info.triangles : 0;
+		const result = original.apply(this, args);
+		if (info) {
+			renderAcc.calls += info.calls - baseCalls;
+			renderAcc.triangles += info.triangles - baseTris;
+			renderAcc.renders++;
+		}
+		return result;
+	};
+	return true;
+}
+
+/** Undo `countRenderCalls` — the sampler stopping must leave the renderer as it found it.
+ * @param {any} renderer */
+export function uncountRenderCalls(renderer) {
+	if (!renderer?.__budgetRender) return;
+	renderer.render = renderer.__budgetRender;
+	delete renderer.__budgetRender;
+}
+
+/** @type {{calls: number, triangles: number, rendersPerFrame: number} | null} */
+let lastTotals = null;
+
+/** Per display frame since the last call, then start a new window. A window with no
+ * frame in it (two forced readings back to back, a paused loop) keeps the previous
+ * reading rather than inventing a zero — "nothing measured" is not "nothing drawn". */
+function takeRenderTotals() {
+	const frames = renderFrames;
+	if (frames === 0) return lastTotals;
+	const out = {
+		calls: Math.round(renderAcc.calls / frames),
+		triangles: Math.round(renderAcc.triangles / frames),
+		rendersPerFrame: Math.round((renderAcc.renders / frames) * 10) / 10
+	};
+	lastTotals = out;
+	renderAcc.calls = 0;
+	renderAcc.triangles = 0;
+	renderAcc.renders = 0;
+	renderFrames = 0;
+	return out;
+}
+
 function sample() {
 	/** @type {any} */
 	const renderer = get(globalRenderer);
+	if (running) countRenderCalls(renderer);
 	const info = renderer?.info;
+	const totals = takeRenderTotals();
 	const profile = profileFor(renderer);
 	const scene = walkScene();
 	const fps = frameStats();
@@ -403,8 +552,11 @@ function sample() {
 		objects: scene.objects,
 		meshes: scene.meshes,
 		hidden: scene.hidden,
-		triangles: info?.render?.triangles ?? null,
-		calls: info?.render?.calls ?? null,
+		// per DISPLAY frame across every render() call; before the sampler has counted a
+		// frame (a forced reading straight after boot) fall back to the raw last pass
+		triangles: totals ? totals.triangles : (info?.render?.triangles ?? null),
+		calls: totals ? totals.calls : (info?.render?.calls ?? null),
+		rendersPerFrame: totals ? totals.rendersPerFrame : null,
 		geometries: info?.memory?.geometries ?? null,
 		textures: info?.memory?.textures ?? null,
 		frameP50: fps.p50,
@@ -449,6 +601,7 @@ function loop() {
 		}
 	}
 	lastFrameAt = now;
+	renderFrames++;
 	if (now - lastSampleAt >= SAMPLE_MS) {
 		lastSampleAt = now;
 		sample();
@@ -467,6 +620,8 @@ export function startSceneMetrics() {
 	running = true;
 	lastFrameAt = 0;
 	lastSampleAt = 0;
+	renderFrames = 0;
+	countRenderCalls(get(globalRenderer));
 	startLongTasks();
 	rafId = requestAnimationFrame(loop);
 }
@@ -476,6 +631,7 @@ export function stopSceneMetrics() {
 	if (rafId != null) cancelAnimationFrame(rafId);
 	rafId = null;
 	stopLongTasks();
+	uncountRenderCalls(get(globalRenderer));
 }
 
 /** Force a reading now — the overlay opening, and the suite. */
diff --git a/tests/e2e/localSignal.cjs b/tests/e2e/localSignal.cjs
new file mode 100644
index 00000000..2d918b67
--- /dev/null
+++ b/tests/e2e/localSignal.cjs
@@ -0,0 +1,74 @@
+// A LOCAL PeerJS signaling server for the multi-peer stress runs (net-stress rig and its
+// regression suite). Flooding the production signaling box with a mesh sweep is abuse,
+// and a shared box on a saturated machine is also the most common source of a two-peer
+// red that has nothing to do with the diff — so these runs bring their own.
+//
+// Port 9001 is MACHINE-WIDE: two lanes share it. Everything that starts it runs under the
+// e2e flock, and a server already listening is REUSED rather than fought over.
+//
+// Pages reach it through `peerServerConfig = {mode:'local'}` (peerServer.js), seeded with
+// `LOCAL_PEER_STORAGE` — never by guessing from the page's hostname.
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const { spawn } = require('child_process');
+
+const SIGNAL_PORT = 9001;
+const ROOT = path.resolve(__dirname, '..', '..');
+const LOCAL_PEER_STORAGE = { peerServerConfig: JSON.stringify({ mode: 'local' }) };
+
+/** @param {number} ms */
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+function signalUp() {
+	return new Promise((resolve) => {
+		const req = https.get(
+			{ host: 'localhost', port: SIGNAL_PORT, path: '/', rejectUnauthorized: false, timeout: 1500 },
+			(res) => {
+				res.resume();
+				resolve(res.statusCode === 200);
+			}
+		);
+		req.on('error', () => resolve(false));
+		req.on('timeout', () => {
+			req.destroy();
+			resolve(false);
+		});
+	});
+}
+
+/** Start the server unless one already answers. Returns the child to stop, or null. */
+async function ensureSignalServer() {
+	if (await signalUp()) return null;
+	const bin = path.join(ROOT, 'node_modules', 'peer', 'dist', 'bin', 'peerjs.js');
+	const key = path.join(ROOT, 'certs', 'localhost.key');
+	const crt = path.join(ROOT, 'certs', 'localhost.crt');
+	if (!fs.existsSync(bin)) throw new Error('the `peer` devDependency is missing — run npm ci');
+	if (!fs.existsSync(key)) throw new Error('certs/localhost.key missing — copy certs/ from another checkout');
+	const child = spawn(process.execPath, [bin, '--port', String(SIGNAL_PORT), '--sslkey', key, '--sslcert', crt], {
+		cwd: ROOT,
+		stdio: 'ignore'
+	});
+	for (let i = 0; i < 40; i++) {
+		await sleep(250);
+		if (await signalUp()) return child;
+	}
+	try {
+		child.kill();
+	} catch {
+		/* already gone */
+	}
+	throw new Error('local PeerJS server did not come up on :' + SIGNAL_PORT);
+}
+
+/** @param {any} child */
+function stopSignalServer(child) {
+	if (!child) return;
+	try {
+		child.kill();
+	} catch {
+		/* already gone */
+	}
+}
+
+module.exports = { SIGNAL_PORT, LOCAL_PEER_STORAGE, signalUp, ensureSignalServer, stopSignalServer };
diff --git a/tests/e2e/net-stress.cjs b/tests/e2e/net-stress.cjs
index 3c776ab2..e80de918 100644
--- a/tests/e2e/net-stress.cjs
+++ b/tests/e2e/net-stress.cjs
@@ -1,7 +1,7 @@
 // B5 — mesh network stress harness (LOCAL PeerJS ONLY).
 //
-//   node tests/e2e/net-stress.cjs [--peers 4,6,8,10] [--load 20] [--objects 20]
-//                                 [--out docs/net-stress.md] [--hz 10]
+//   node tests/e2e/net-stress.cjs [--peers 8,10,12,16] [--load 20] [--objects 20]
+//                                 [--out docs/net-stress.md] [--hz 10] [--presence 10]
 //
 // NOT a .test.cjs on purpose: a full sweep runs for many minutes, well past the
 // runner's per-suite timeout. `npm run e2e -- net-stress` runs the small
@@ -14,20 +14,25 @@
 //   - message loss   — sequence numbers over a synthetic mutation load
 //   - fan-out cost   — wall time of one PeerConnection.send() across N-1 conns
 //   - renderer FPS   — idle baseline vs under load (relative; see the caveat below)
+//   - long tasks/min — main-thread blocks over 50ms per peer under the load (25-G)
+//   - presence       — with --presence N, every peer orbits its camera for N seconds and
+//                      each counts the `camera` messages it RECEIVES per sender: the
+//                      audit-H7 stream, now rate-gated (25-C), at mesh scale (25-G)
 //
 // HARD RULE: local signaling server only. Pointing a 10-peer flood at the public
-// or self-hosted production box is abuse, so the harness refuses any APP_URL that
-// isn't localhost and spawns its own `peer` server on :9001 (the same one the
-// .vscode "peerjs" task starts).
+// or self-hosted production box is abuse, so the harness spawns its own `peer` server on
+// :9001 (localSignal.cjs) and SEEDS every page with `peerServerConfig = {mode:'local'}` —
+// which is what actually keeps the pages off production, whatever the app's hostname.
+// The APP_URL must still resolve to this machine (a lane serves theprototype.app via
+// /etc/hosts), so the dev server being flooded is our own.
 //
 // CAVEAT on FPS: N headless Chromium contexts each render a WebGL scene on the
-// same machine (SwiftShader, no GPU), so absolute FPS says more about the host
-// than about the protocol. Only the idle-vs-load DELTA at a given N is meaningful.
+// same machine, so absolute FPS says more about the host than about the protocol.
+// Only the idle-vs-load DELTA at a given N is meaningful. The rig launches with
+// GPU_ARGS; on a box without a GPU that silently falls back to SwiftShader.
 
 const fs = require('fs');
 const path = require('path');
-const https = require('https');
-const { spawn } = require('child_process');
 
 // ---------------------------------------------------------------- arguments
 const argv = process.argv.slice(2);
@@ -36,7 +41,7 @@ function arg(name, fallback) {
 	const i = argv.indexOf('--' + name);
 	return i >= 0 && argv[i + 1] ? argv[i + 1] : fallback;
 }
-const SIZES = arg('peers', '4,6,8,10')
+const SIZES = arg('peers', '8,10,12,16')
 	.split(',')
 	.map((n) => parseInt(n, 10))
 	.filter((n) => n >= 2);
@@ -44,6 +49,8 @@ const LOAD_SECS = parseInt(arg('load', '20'), 10);
 const HZ = parseInt(arg('hz', '10'), 10);
 const OBJECTS = parseInt(arg('objects', '20'), 10);
 const OUT = arg('out', '');
+// 25-G: seconds of continuous camera motion on every peer; 0 = skip the presence phase
+const PRESENCE_SECS = parseInt(arg('presence', '0'), 10);
 // --logs echoes each page's own console (peerHandler is chatty about the connect
 // dance) with a ms stamp, which is the only way to see WHY a join stalls
 const LOGS = argv.includes('--logs');
@@ -53,52 +60,17 @@ const T0 = Date.now();
 const APP_URL = process.env.APP_URL || 'https://localhost:5185/';
 process.env.APP_URL = APP_URL;
 const host = new URL(APP_URL).hostname;
-if (!/^(localhost|127\.0\.0\.1|\[?::1\]?)$/.test(host)) {
-	console.error(
-		'REFUSING to run: APP_URL host is "' + host + '".\n' +
-			'The stress harness floods the signaling server and must only ever point at a\n' +
-			'LOCAL dev server (which routes PeerJS to localhost:9001). See the file header.'
-	);
-	process.exit(2);
-}
-
 const h = require('./helpers.cjs');
-
-// ------------------------------------------------------- local peerjs server
-const SIGNAL_PORT = 9001;
-
-function signalUp() {
-	return new Promise((resolve) => {
-		const req = https.get(
-			{ host: 'localhost', port: SIGNAL_PORT, path: '/', rejectUnauthorized: false, timeout: 1500 },
-			(res) => {
-				res.resume();
-				resolve(res.statusCode === 200);
-			}
-		);
-		req.on('error', () => resolve(false));
-		req.on('timeout', () => { req.destroy(); resolve(false); });
-	});
-}
-
-async function ensureSignalServer() {
-	if (await signalUp()) return null;
-	const bin = path.join(ROOT, 'node_modules', 'peer', 'dist', 'bin', 'peerjs.js');
-	const key = path.join(ROOT, 'certs', 'localhost.key');
-	const crt = path.join(ROOT, 'certs', 'localhost.crt');
-	if (!fs.existsSync(bin)) throw new Error('the `peer` devDependency is missing — run npm ci');
-	if (!fs.existsSync(key)) throw new Error('certs/localhost.key missing — run npm run certs');
-	console.log('starting local PeerJS server on :' + SIGNAL_PORT);
-	const child = spawn(process.execPath, [bin, '--port', String(SIGNAL_PORT), '--sslkey', key, '--sslcert', crt], {
-		cwd: ROOT,
-		stdio: 'ignore'
-	});
-	for (let i = 0; i < 40; i++) {
-		await sleep(250);
-		if (await signalUp()) return child;
-	}
-	try { child.kill(); } catch { /* already gone */ }
-	throw new Error('local PeerJS server did not come up on :' + SIGNAL_PORT);
+const { SIGNAL_PORT, LOCAL_PEER_STORAGE, ensureSignalServer } = require('./localSignal.cjs');
+
+/** Does the APP_URL host resolve to this machine? @param {string} name */
+function isLoopback(name) {
+	if (/^(localhost|127\.0\.0\.1|\[?::1\]?)$/.test(name)) return Promise.resolve(true);
+	return new Promise((resolve) =>
+		require('dns').lookup(name, { all: true }, (err, addrs) =>
+			resolve(!err && addrs.length > 0 && addrs.every((a) => a.address === '127.0.0.1' || a.address === '::1'))
+		)
+	);
 }
 
 // ------------------------------------------------------------------- utils
@@ -147,9 +119,43 @@ function installProbe(peer) {
 			// per-type traffic accounting — ON during joins (where the interesting
 			// asymmetry is), OFF under load so the sizing cost can't skew FPS
 			accounting: true,
-			traffic: { count: 0, bytes: 0, byType: {} }
+			traffic: { count: 0, bytes: 0, byType: {} },
+			// 25-G: camera messages received per SENDER, and the main thread's long tasks
+			cam: {},
+			tasks: []
 		});
 		ns.pc = pc;
+		if (!ns.taskObserver) {
+			try {
+				ns.taskObserver = new PerformanceObserver((list) => {
+					for (const e of list.getEntries()) ns.tasks.push(e.startTime);
+				});
+				ns.taskObserver.observe({ entryTypes: ['longtask'] });
+			} catch {
+				ns.taskObserver = null;
+			}
+		}
+		/** long tasks that started in the last `ms` */
+		ns.tasksIn = (/** @type {number} */ ms) => ns.tasks.filter((/** @type {number} */ t) => t >= performance.now() - ms).length;
+		/** orbit the editor camera every frame until stopped — the presence stream's source */
+		ns.orbitStart = () => {
+			let controls;
+			w.__stores.orbitControls.subscribe((/** @type {any} */ c) => (controls = c))();
+			ns.orbitFrames = 0;
+			ns.orbiting = true;
+			const tick = () => {
+				if (!ns.orbiting) return;
+				if (controls?._rotateLeft) controls._rotateLeft(0.03);
+				controls?.update?.();
+				ns.orbitFrames++;
+				requestAnimationFrame(tick);
+			};
+			requestAnimationFrame(tick);
+		};
+		ns.orbitStop = () => {
+			ns.orbiting = false;
+			return ns.orbitFrames;
+		};
 
 		/** rough wire size; binarypack is compact but relative sizes are what matter */
 		ns.sizeOf = (/** @type {any} */ d) => {
@@ -196,6 +202,7 @@ function installProbe(peer) {
 				ns.hooked.add(c);
 				added++;
 				c.on('data', (/** @type {any} */ d) => {
+					if (d && d.type === 'camera' && d.peerId) ns.cam[d.peerId] = (ns.cam[d.peerId] || 0) + 1;
 					if (ns.accounting && d) {
 						const t = typeof d === 'string' ? 'string' : d.type || 'unknown';
 						const tr = ns.traffic;
@@ -364,7 +371,7 @@ async function runSize(N) {
 			// measures render starvation. We want the NETWORK to be the bottleneck.
 			const p = await h.setupPage(browser, 'P' + i, {
 				context: { viewport: { width: 800, height: 600 } },
-				storage: { viewMode: 'shaded' }
+				storage: { viewMode: 'shaded', ...LOCAL_PEER_STORAGE }
 			});
 			if (LOGS) {
 				const tag = 'P' + i + '/' + p.id;
@@ -499,12 +506,65 @@ async function runSize(N) {
 
 		// --- load: every peer broadcasts `move` at hz for `secs`, then a ramp to
 		// find where the mesh actually starts hurting
+		/**
+		 * 25-G: every peer orbits its camera for `secs`, and each counts the `camera` messages
+		 * it RECEIVES per sender. The rate is per sender per receiver, stated beside the
+		 * sender's own frame count — a 50ms gate at 60fps is ~0.33 messages a frame.
+		 * @param {number} secs
+		 */
+		const presencePhase = async (secs) => {
+			for (const p of peers) await p.page.evaluate(() => window.__ns.hook());
+			for (const p of peers) await p.page.evaluate(() => { window.__ns.cam = {}; });
+			for (const p of peers) await p.page.evaluate(() => window.__ns.orbitStart());
+			await sleep(secs * 1000);
+			const frames = [];
+			for (const p of peers) frames.push(await p.page.evaluate(() => window.__ns.orbitStop()));
+			const longPerMin = [];
+			for (const p of peers) longPerMin.push(await p.page.evaluate((ms) => window.__ns.tasksIn(ms), secs * 1000));
+			await sleep(1000);
+			/** received camera msgs/s per peer, summed over every sender */
+			const receivedPerPeer = [];
+			/** per sender->receiver pair, msgs per sender frame */
+			const perFrame = [];
+			let pairsSilent = 0;
+			for (let i = 0; i < N; i++) {
+				const cam = await peers[i].page.evaluate(() => ({ ...window.__ns.cam }));
+				let total = 0;
+				for (let j = 0; j < N; j++) {
+					if (i === j) continue;
+					const got = cam[peers[j].id] || 0;
+					total += got;
+					if (!got) pairsSilent++;
+					if (frames[j]) perFrame.push(got / frames[j]);
+				}
+				receivedPerPeer.push(total / secs);
+			}
+			const out = {
+				secs,
+				senderFps: median(frames.map((f) => f / secs)),
+				receivedPerPeerPerSec: median(receivedPerPeer),
+				maxReceivedPerPeerPerSec: Math.max(...receivedPerPeer),
+				msgsPerSenderFrame: stats(perFrame),
+				pairsSilent,
+				longTasksPerMin: median(longPerMin.map((n) => (n * 60) / secs)),
+				maxLongTasksPerMin: Math.max(...longPerMin.map((n) => (n * 60) / secs))
+			};
+			console.log(
+				'  presence: ' + r(out.receivedPerPeerPerSec) + ' camera msgs/s received per peer (max ' + r(out.maxReceivedPerPeerPerSec) + ')' +
+					', ' + r(out.msgsPerSenderFrame.p50, 2) + ' msgs per sender frame, sender fps ' + r(out.senderFps) +
+					', silent pairs ' + pairsSilent + ', long tasks/min ' + r(out.longTasksPerMin) + ' (max ' + r(out.maxLongTasksPerMin) + ')'
+			);
+			return out;
+		};
+
 		/** @param {number} hz @param {number} secs */
 		const loadPhase = async (hz, secs) => {
 			for (const p of peers) await p.page.evaluate(() => window.__ns.hook());
 			for (const p of peers) await p.page.evaluate(() => window.__ns.fpsStart());
 			for (const p of peers) await p.page.evaluate(([u, z]) => window.__ns.startLoad(u, z), [uuid, hz]);
 			await sleep(secs * 1000);
+			const longPerMin = [];
+			for (const p of peers) longPerMin.push(await p.page.evaluate((ms) => window.__ns.tasksIn(ms), secs * 1000));
 			const sent = [];
 			for (const p of peers) sent.push(await p.page.evaluate(() => window.__ns.stopLoad()));
 			const fps = [];
@@ -549,6 +609,7 @@ async function runSize(N) {
 				sendMs: stats(sendMs),
 				oneWay: stats(lat),
 				fps: median(fps),
+				longTasksPerMin: median(longPerMin.map((n) => (n * 60) / secs)),
 				msgs: { expected, got, lossPct: expected ? (100 * (expected - got)) / expected : 0 },
 				meshMsgsPerSec: hz * N * (N - 1)
 			};
@@ -564,6 +625,7 @@ async function runSize(N) {
 		};
 
 		row.steady = await loadPhase(HZ, LOAD_SECS);
+		if (PRESENCE_SECS > 0) row.presence = await presencePhase(PRESENCE_SECS);
 		row.ramp = [];
 		for (const hz of [30, 60, 120]) row.ramp.push(await loadPhase(hz, 8));
 
@@ -624,8 +686,8 @@ function report(rows) {
 	lines.push('');
 	lines.push('## Load ramp (8s per step; "emitted" = what the send timer actually managed)');
 	lines.push('');
-	lines.push('| N | Hz/peer | mesh msgs/s | loss | one-way p50/p95 | send() p95 | fps | emitted/wanted |');
-	lines.push('|---|---|---|---|---|---|---|---|');
+	lines.push('| N | Hz/peer | mesh msgs/s | loss | one-way p50/p95 | send() p95 | fps | long tasks/min | emitted/wanted |');
+	lines.push('|---|---|---|---|---|---|---|---|---|');
 	for (const w of rows) {
 		for (const s of [w.steady, ...(w.ramp || [])]) {
 			if (!s) continue;
@@ -634,10 +696,29 @@ function report(rows) {
 					' | ' + r(s.oneWay.p50) + ' / ' + r(s.oneWay.p95) +
 					' | ' + r(s.sendMs.p95, 2) +
 					' | ' + r(s.fps) +
+					' | ' + r(s.longTasksPerMin) +
 					' | ' + r(s.sentPerPeer, 0) + '/' + s.wantedPerPeer + ' |'
 			);
 		}
 	}
+	if (rows.some((w) => w.presence)) {
+		lines.push('');
+		lines.push('## Presence (25-G): every peer orbiting for ' + PRESENCE_SECS + 's');
+		lines.push('');
+		lines.push('| N | sender fps | camera msgs/s received per peer (median / max) | msgs per sender frame p50/max | silent pairs | long tasks/min (median / max) |');
+		lines.push('|---|---|---|---|---|---|');
+		for (const w of rows) {
+			const p = w.presence;
+			if (!p) continue;
+			lines.push(
+				'| ' + w.N + ' | ' + r(p.senderFps) +
+					' | ' + r(p.receivedPerPeerPerSec) + ' / ' + r(p.maxReceivedPerPeerPerSec) +
+					' | ' + r(p.msgsPerSenderFrame.p50, 2) + ' / ' + r(p.msgsPerSenderFrame.max, 2) +
+					' | ' + p.pairsSilent +
+					' | ' + r(p.longTasksPerMin) + ' / ' + r(p.maxLongTasksPerMin) + ' |'
+			);
+		}
+	}
 	lines.push('');
 	lines.push('```json');
 	lines.push(JSON.stringify(rows, null, 1));
@@ -649,6 +730,13 @@ function report(rows) {
 (async () => {
 	let server = null;
 	try {
+		if (!(await isLoopback(host))) {
+			console.error(
+				'REFUSING to run: APP_URL host "' + host + '" does not resolve to this machine.\n' +
+					'The rig floods its dev server and must only ever point at a LOCAL one. See the file header.'
+			);
+			process.exit(2);
+		}
 		server = await ensureSignalServer();
 		console.log('app: ' + APP_URL + '   signaling: https://localhost:' + SIGNAL_PORT);
 		const rows = [];
diff --git a/tests/e2e/net-stress.test.cjs b/tests/e2e/net-stress.test.cjs
index 8dfb67d1..ef68d23b 100644
--- a/tests/e2e/net-stress.test.cjs
+++ b/tests/e2e/net-stress.test.cjs
@@ -1,35 +1,53 @@
-// 27-I — THE SMALL MESH REGRESSION SUITE.
+// 27-I + 25-G — THE MESH REGRESSION SUITE, on FOUR peers and a LOCAL signaling server.
 //
-// `net-stress.cjs` beside this file is the MEASUREMENT RIG: a many-minute sweep across
-// mesh sizes that spawns its own signaling server and refuses any non-localhost APP_URL.
-// Its header has always pointed at this file for the quick check, and this file did not
-// exist — so `npm run e2e -- net-stress` matched the rig's name and ran nothing.
+// `net-stress.cjs` beside this file is the MEASUREMENT RIG (a many-minute sweep across
+// mesh sizes). This is the quick check that would catch a real regression in what the rig
+// measures. 27-I shipped it on three peers against the shared signaling box; 25-G makes it
+// what that brief asked for:
+//   - N=4, because with three peers the host's `hosts` roster only ever names ONE other
+//     peer, so a fill that mishandled a list longer than one (only the first id, only the
+//     last) would still pass. With four, each fill has to reach two peers that never
+//     dialled each other — six of the twelve links come from the fill alone.
+//   - a LOCAL `peer` server on :9001 (localSignal.cjs), so a signaling hiccup on a shared
+//     box can no longer masquerade as a mesh regression, and nothing floods production.
 //
-// What this pins, on a THREE-peer mesh, is the handful of properties the rig measures
-// that would be a real regression if they broke:
-//   1. the mesh FILLS — a late joiner dials one peer and ends up connected to both
+// What this pins:
+//   1. the mesh FILLS — every one of the 12 ordered pairs is open (pair-complete: a link
+//      that never formed is exactly the loss a user feels)
 //   2. a broadcast reaches every peer with NO loss, by sequence number
-//   3. one send's fan-out cost stays bounded (it is a per-conn loop, never batched)
-//   4. the same, while a second sender is loading the mesh — nobody starves
+//   3. all FOUR broadcasting at once: every ordered pair delivers whole — nobody starves
+//   4. one send's fan-out cost stays bounded
+//   5. the PRESENCE stream (roadmap 25 3c/3d, audit H7): four peers orbiting at display
+//      rate send `camera` at the gated rate (20/s desktop), NOT once per frame — with a
+//      premise that every sender drew well above the gate, so per-frame would be visible
+//   6. the main thread under that load: long tasks per peer are recorded and bounded
 //
-// The probe rides a REAL `move` payload with additive `__ns` fields, which is the rig's
-// own trick and matters twice over: it exercises the real applier path, and since 27-A
-// validates every incoming message, a made-up uuid would be REJECTED by that guard — so
-// the probe carries an actual object's uuid.
+// The probe rides a REAL `move` payload with additive `__ns` fields: 27-A validates every
+// incoming message, so a made-up uuid would be rejected — the probe carries a real uuid.
 //
-// Run: APP_URL=https://theprototype.app:5175/ npm run e2e -- net-stress.test
+// Run: APP_URL=https://theprototype.app:5180/ npm run e2e -- net-stress.test
 const h = require('./helpers.cjs');
+const { LOCAL_PEER_STORAGE, ensureSignalServer, stopSignalServer } = require('./localSignal.cjs');
 
-/** A reduced installProbe: hook every conn, count probe messages per sender by seq. */
+/** Hook every conn; count probe messages per sender by seq, and presence per sender. */
 const installProbe = (peer) =>
 	peer.page.evaluate((myId) => {
 		const w = window;
 		let pc;
 		w.__stores.peers.subscribe((p) => (pc = p))();
-		const ns = (w.__probe = w.__probe || { myId, hooked: new WeakSet(), rx: {}, sendMs: [], seq: 0 });
+		const ns = (w.__probe = w.__probe || { myId, hooked: new WeakSet(), rx: {}, cam: {}, sendMs: [], tasks: [] });
 		ns.pc = pc;
-		// the app's outgoing map AND peerjs's own, which also holds INBOUND conns — an
-		// ack can come back over a conn this peer never dialled
+		if (!ns.observer) {
+			try {
+				ns.observer = new PerformanceObserver((list) => {
+					for (const e of list.getEntries()) ns.tasks.push({ at: e.startTime, ms: e.duration });
+				});
+				ns.observer.observe({ entryTypes: ['longtask'] });
+			} catch {
+				ns.observer = null;
+			}
+		}
+		// the app's outgoing map AND peerjs's own, which also holds INBOUND conns
 		ns.allConns = () => {
 			const seen = new Set();
 			const out = [];
@@ -48,7 +66,9 @@ const installProbe = (peer) =>
 				if (ns.hooked.has(c)) continue;
 				ns.hooked.add(c);
 				c.on('data', (d) => {
-					if (!d || d.__ns !== 'probe') return;
+					if (!d) return;
+					if (d.type === 'camera' && d.peerId) ns.cam[d.peerId] = (ns.cam[d.peerId] || 0) + 1;
+					if (d.__ns !== 'probe') return;
 					const s = ns.rx[d.__from] || (ns.rx[d.__from] = { count: 0, maxSeq: -1 });
 					s.count++;
 					if (d.__seq > s.maxSeq) s.maxSeq = d.__seq;
@@ -56,7 +76,6 @@ const installProbe = (peer) =>
 			}
 			return ns.allConns().length;
 		};
-		// conns keep appearing through the join phase, so keep re-scanning
 		ns.hook();
 		if (!ns.auto) ns.auto = setInterval(() => ns.hook(), 250);
 		ns.send = (uuid, seq) => {
@@ -74,10 +93,11 @@ const installProbe = (peer) =>
 			ns.sendMs.push(performance.now() - t);
 		};
 		// `maxSeq` is a RUNNING MAXIMUM and `count` accumulates, so a later section that
-		// sends fewer messages than an earlier one cannot lower either — without this the
-		// two-way check below passes on numbers left over from the first blast.
+		// sends fewer messages than an earlier one cannot lower either — every section that
+		// counts starts from a reset, or it passes on numbers left over from the last one.
 		ns.reset = () => {
 			ns.rx = {};
+			ns.cam = {};
 		};
 		ns.blast = async (uuid, count, gapMs) => {
 			ns.sendMs = [];
@@ -87,6 +107,28 @@ const installProbe = (peer) =>
 			}
 			return { sent: count, maxSendMs: Math.max(...ns.sendMs) };
 		};
+		// orbit the editor camera every frame for `ms`, counting our own frames — the
+		// presence stream's send rate is stated against THIS number
+		ns.orbit = async (ms) => {
+			let controls;
+			w.__stores.orbitControls.subscribe((c) => (controls = c))();
+			const started = performance.now();
+			let frames = 0;
+			const taskFrom = ns.tasks.length;
+			while (performance.now() - started < ms) {
+				await new Promise((r) => requestAnimationFrame(r));
+				if (controls?._rotateLeft) controls._rotateLeft(0.03);
+				controls?.update?.();
+				frames++;
+			}
+			const tasks = ns.tasks.slice(taskFrom);
+			return {
+				frames,
+				elapsed: performance.now() - started,
+				longTasks: tasks.length,
+				longest: tasks.reduce((m, t) => Math.max(m, t.ms), 0)
+			};
+		};
 		return true;
 	}, peer.id);
 
@@ -96,81 +138,149 @@ const received = (peer, fromId) =>
 		return s ? { count: s.count, maxSeq: s.maxSeq } : { count: 0, maxSeq: -1 };
 	}, fromId);
 
-const openConns = (peer) =>
+const openPeers = (peer) =>
 	peer.page.evaluate(() => {
 		let pc;
 		window.__stores.peers.subscribe((p) => (pc = p))();
-		return pc?.openedPeers?.size ?? 0;
+		return [...(pc?.openedPeers ?? [])];
 	});
 
 h.run(async () => {
-	const browser = await h.launch();
-	const A = await h.setupPage(browser, 'A');
-	const B = await h.setupPage(browser, 'B');
-	const C = await h.setupPage(browser, 'C');
+	/** @type {any} */
+	let browserRef = null;
+	const signal = await ensureSignalServer();
+	try {
+		// GPU args: section 5 is a RATE claim against display frames, and a SwiftShader page
+		// at ~2.5fps can never exercise a 50ms gate (the e2e skill's rule)
+		const browser = (browserRef = await h.launch({ args: h.GPU_ARGS }));
+		const opts = { storage: LOCAL_PEER_STORAGE, context: { viewport: { width: 800, height: 600 } } };
+		const peers = [];
+		for (const name of ['A', 'B', 'C', 'D']) peers.push(await h.setupPage(browser, name, opts));
+		const [A, B, C, D] = peers;
+		const server = await A.page.evaluate(() => {
+			let s;
+			window.__stores.peerServer.peerServerStatus.subscribe((v) => (s = v))();
+			return s;
+		});
+		h.check(server?.kind === 'local', `premise: the peers signal through the LOCAL server (${JSON.stringify(server)})`);
 
-	// ---- 1. the mesh fills -------------------------------------------------------------
-	await h.connect(B, A);
-	// a CONNECTED peer's pill has no dial input, so the late joiner dials the HOST
-	await h.connect(C, A);
-	await h.eventually(() => openConns(C), (n) => n >= 2, 'the late joiner ends up connected to BOTH peers', 30000);
-	await h.eventually(() => openConns(A), (n) => n >= 2, 'the host holds both connections', 20000);
-	await h.eventually(() => openConns(B), (n) => n >= 2, 'and the first joiner was filled in by the mesh', 20000);
+		// ---- 1. the mesh fills -----------------------------------------------------------
+		// a CONNECTED peer's pill has no dial input, so every joiner dials the HOST
+		await h.connect(B, A);
+		await h.connect(C, A);
+		await h.connect(D, A);
+		/** every ordered pair (i sees j open) */
+		const pairState = async () => {
+			const lists = [];
+			for (const p of peers) lists.push(await openPeers(p));
+			const missing = [];
+			peers.forEach((p, i) =>
+				peers.forEach((q, j) => {
+					if (i !== j && !lists[i].includes(q.id)) missing.push(`${'ABCD'[i]}->${'ABCD'[j]}`);
+				})
+			);
+			return missing;
+		};
+		await h.eventually(pairState, (m) => m.length === 0, 'all 12 ordered pairs of a four-peer mesh are open', 45000);
+		const missing = await pairState();
+		h.check(
+			missing.length === 0,
+			`the mesh is FULL — B, C and D each dialled only the host (missing: ${JSON.stringify(missing)})`
+		);
 
-	// a REAL object, so the probe's `move` survives the 27-A wire validator
-	const uuid = await A.page.evaluate(() => {
-		window.__stores.addObjects.spawnAtPoint('/create Box 1 1 1', [3, 0.5, -2]);
-		return new Promise((resolve) =>
-			window.__stores.objectsGroup.subscribe((g) => {
-				const o = g.children[g.children.length - 1];
-				resolve(o ? o.uuid : null);
-			})()
+		// a REAL object, so the probe's `move` survives the 27-A wire validator
+		const uuid = await A.page.evaluate(() => {
+			window.__stores.addObjects.spawnAtPoint('/create Box 1 1 1', [3, 0.5, -2]);
+			return new Promise((resolve) =>
+				window.__stores.objectsGroup.subscribe((g) => {
+					const o = g.children[g.children.length - 1];
+					resolve(o ? o.uuid : null);
+				})()
+			);
+		});
+		h.check(!!uuid, `premise: a real object to address, so the probe is not rejected as malformed (${uuid})`);
+		await h.eventually(
+			() => D.page.evaluate((u) => !!window.__stores.objectsGroup && (() => { let g; window.__stores.objectsGroup.subscribe((v) => (g = v))(); return !!g.getObjectByProperty('uuid', u); })(), uuid),
+			(ok) => ok,
+			'premise: the object reached the last joiner',
+			15000
 		);
-	});
-	h.check(!!uuid, `premise: a real object to address, so the probe is not rejected as malformed (${uuid})`);
-	await A.page.waitForTimeout(800);
 
-	for (const p of [A, B, C]) await installProbe(p);
-	await A.page.waitForTimeout(600);
+		for (const p of peers) await installProbe(p);
+		await A.page.waitForTimeout(600);
 
-	// ---- 2. a broadcast reaches everyone, with no loss ----------------------------------
-	const blast = await A.page.evaluate(
-		([u, n, gap]) => window.__probe.blast(u, n, gap),
-		[uuid, 60, 25]
-	);
-	h.check(blast.sent === 60, `premise: the host sent 60 probe messages (${blast.sent})`);
-	await A.page.waitForTimeout(1200);
+		// ---- 2. a broadcast reaches everyone, with no loss -------------------------------
+		const blast = await A.page.evaluate(([u, n, gap]) => window.__probe.blast(u, n, gap), [uuid, 60, 25]);
+		h.check(blast.sent === 60, `premise: the host sent 60 probe messages (${blast.sent})`);
+		await A.page.waitForTimeout(1200);
+		for (const p of [B, C, D]) {
+			const got = await received(p, A.id);
+			h.check(got.count === 60 && got.maxSeq === 59, `${p === B ? 'B' : p === C ? 'C' : 'D'} got every host message, tail included (${got.count}/60, maxSeq ${got.maxSeq})`);
+		}
 
-	const atB = await received(B, A.id);
-	const atC = await received(C, A.id);
-	h.check(atB.count === 60, `every message reached the first joiner (${atB.count}/60, maxSeq ${atB.maxSeq})`);
-	h.check(atC.count === 60, `every message reached the late joiner (${atC.count}/60, maxSeq ${atC.maxSeq})`);
-	h.check(
-		atB.maxSeq === 59 && atC.maxSeq === 59,
-		`and the LAST one arrived, so nothing was dropped off the tail (${atB.maxSeq}, ${atC.maxSeq})`
-	);
+		// ---- 4. fan-out cost stays bounded ------------------------------------------------
+		h.check(blast.maxSendMs < 250, `one broadcast's fan-out stays bounded (worst send ${blast.maxSendMs.toFixed(1)}ms across 3 conns)`);
 
-	// ---- 3. fan-out cost stays bounded --------------------------------------------------
-	// `send` is a per-conn loop with no batching, so this is the number that grows with N.
-	h.check(
-		blast.maxSendMs < 250,
-		`one broadcast's fan-out stays bounded (worst send ${blast.maxSendMs.toFixed(1)}ms across 2 conns)`
-	);
+		// ---- 3. all four at once: every ordered pair whole --------------------------------
+		for (const p of peers) await p.page.evaluate(() => window.__probe.reset());
+		await Promise.all(peers.map((p) => p.page.evaluate(([u, n, gap]) => window.__probe.blast(u, n, gap), [uuid, 40, 25])));
+		await A.page.waitForTimeout(1800);
+		let pairsWhole = 0;
+		const broken = [];
+		for (let i = 0; i < 4; i++) {
+			for (let j = 0; j < 4; j++) {
+				if (i === j) continue;
+				const got = await received(peers[i], peers[j].id);
+				if (got.count === 40 && got.maxSeq === 39) pairsWhole++;
+				else broken.push(`${'ABCD'[j]}->${'ABCD'[i]} ${got.count}/40`);
+			}
+		}
+		h.check(pairsWhole === 12, `under four-way load every ordered pair delivered whole (${pairsWhole}/12 ${JSON.stringify(broken)})`);
 
-	// ---- 4. two senders at once: nobody starves -----------------------------------------
-	// clear the counters first, or section 2's seq 59 makes this check unfalsifiable
-	for (const p of [A, B, C]) await p.page.evaluate(() => window.__probe.reset());
-	await Promise.all([
-		A.page.evaluate(([u, n, gap]) => window.__probe.blast(u, n, gap), [uuid, 40, 25]),
-		B.page.evaluate(([u, n, gap]) => window.__probe.blast(u, n, gap), [uuid, 40, 25])
-	]);
-	await A.page.waitForTimeout(1500);
-	const cFromA = await received(C, A.id);
-	const cFromB = await received(C, B.id);
-	h.check(
-		cFromA.maxSeq === 39 && cFromB.maxSeq === 39 && cFromA.count === 40 && cFromB.count === 40,
-		`under two-way load the late joiner got both streams WHOLE (A ${cFromA.count}/40 seq ${cFromA.maxSeq}, B ${cFromB.count}/40 seq ${cFromB.maxSeq})`
-	);
+		// ---- 5. the presence stream is throttled, not per frame ---------------------------
+		for (const p of peers) await p.page.evaluate(() => window.__probe.reset());
+		const runs = await Promise.all(peers.map((p) => p.page.evaluate((ms) => window.__probe.orbit(ms), 3000)));
+		// read at once: OrbitControls damping keeps the camera drifting (and sending) after the
+		// orbit loop stops, and those messages belong to no measured frame window
+		const cams = [];
+		for (const p of peers) cams.push(await p.page.evaluate(() => ({ ...window.__probe.cam })));
+		// the claim is only testable when a per-frame sender would EXCEED the gate: 25-C gates
+		// the desktop camera at 50ms (20/s), so every peer must be drawing well above that
+		h.check(
+			runs.every((r) => (r.frames * 1000) / r.elapsed >= 40),
+			`premise: every peer ran well above the 20/s gate while orbiting (${runs.map((r) => Math.round((r.frames * 1000) / r.elapsed)).join(', ')} fps)`
+		);
+		// per SENDER, as seen by every other peer, in messages per second of orbit
+		const rates = [];
+		let flowing = true;
+		peers.forEach((sender, j) => {
+			peers.forEach((_, i) => {
+				if (i === j) return;
+				const got = cams[i][sender.id] || 0;
+				if (got < 10) flowing = false;
+				rates.push(Math.round((got / (runs[j].elapsed / 1000)) * 10) / 10);
+			});
+		});
+		h.check(flowing, `premise: the camera stream flows between every pair while orbiting (${JSON.stringify(cams.map((c) => Object.values(c)))})`);
+		const worst = Math.max(...rates);
+		const slowestFps = Math.min(...runs.map((r) => (r.frames * 1000) / r.elapsed));
+		// 20/s plus slack for in-flight messages at the cut; a per-frame sender
+		// would read at its frame rate, which the premise put at 40 or more
+		h.check(
+			worst <= 25 && worst < slowestFps * 0.65,
+			`presence is gated, not per frame: worst ${worst} msgs/s per sender against >= ${Math.round(slowestFps)} fps (all ${JSON.stringify(rates)})`
+		);
 
-	await h.finish(browser);
+		// ---- 6. the main thread under the load --------------------------------------------
+		const longest = Math.max(...runs.map((r) => r.longest));
+		console.log('long tasks while four peers orbit: ' + JSON.stringify(runs.map((r) => ({ n: r.longTasks, longest: Math.round(r.longest) }))));
+		h.check(longest < 1000, `no peer froze while four orbit and stream presence (longest task ${Math.round(longest)}ms)`);
+	} catch (error) {
+		stopSignalServer(signal);
+		throw error;
+	}
+	// `finish` exits the process, so the server we started is stopped BEFORE it — a
+	// leftover listener on the machine-wide :9001 would be reused by the next lane's run
+	stopSignalServer(signal);
+	await h.finish(browserRef);
 });
diff --git a/tests/e2e/perf-governor.test.cjs b/tests/e2e/perf-governor.test.cjs
new file mode 100644
index 00000000..cabb9997
--- /dev/null
+++ b/tests/e2e/perf-governor.test.cjs
@@ -0,0 +1,370 @@
+// 26-D — the adaptive quality governor (roadmap 26 section 4, Stage 1).
+//
+// The decision RULE is unit-tested (tests/unit/qualityGovernor.test.js). This suite proves
+// the WIRING against the live app, in the order it matters:
+//   1. a light scene on a slow machine is never governed (the 26-G ruling, held)
+//   2. a heavy slow scene takes the first step: shadows go off on the renderer, the user's
+//      saved shadowQuality is NOT written, the chip appears, the baseline is recorded
+//   3. THE 26-G INTERACTION: a heavy scene whose draw calls the governor has brought down to
+//      green still reads as heavy to the freeze guard, and a frozen streak still pauses
+//   4. every step reaches its consumer (the real pixel ratio, the composer's buffer size) and
+//      walking back restores it exactly
+//   5. recovery on good frames, the chip's pin and release (with the release snooze), and the
+//      opt-out
+//   6. the INGEST DRAW GAP (26-E's finding): while a batch drains through slow frames the
+//      renderer draws at most ~4 frames a second, sticky for the drain, off when it ends
+//   7. END TO END on real frames: 3,000 real boxes on a real GPU engage the governor on their
+//      own, and the measured draw calls fall
+//
+// Sections 1-6 stop the budget sampler so the metrics and frames are the suite's to write
+// (the overload-guard suite's pattern); section 7 turns it back on.
+//
+// Run: APP_URL=https://theprototype.app:5180/ npm run e2e -- perf-governor
+const h = require('./helpers.cjs');
+const { installProbe } = require('./sceneStressProbe.cjs');
+
+h.run(async () => {
+	const browser = await h.launch({ args: h.GPU_ARGS });
+	const A = await h.setupPage(browser, 'A');
+	await installProbe(A.page);
+
+	// shared in-page helpers
+	await A.page.evaluate(() => {
+		const s = window.__stores;
+		const read = (store) => {
+			let v;
+			store.subscribe((x) => (v = x))();
+			return v;
+		};
+		window.__gov = {
+			read,
+			/** synthetic frames of `ms` for `durationMs`, ending at a time we choose */
+			frames(ms, durationMs) {
+				const q = s.qualityGovernor.governorForTest;
+				let t = window.__gov.clock;
+				const end = t + durationMs;
+				while (t < end) {
+					t += ms;
+					q.frame(ms, t);
+				}
+				window.__gov.clock = t;
+				return t;
+			},
+			decide() {
+				return s.qualityGovernor.decideNow(window.__gov.clock);
+			},
+			metrics(m) {
+				s.sceneBudget.sceneMetrics.set({ at: Date.now(), profile: 'desktop', ...m });
+			},
+			clock: 1e7
+		};
+	});
+
+	const snap = () =>
+		A.page.evaluate(() => {
+			const s = window.__stores;
+			const { read } = window.__gov;
+			const r = read(s.globalRenderer);
+			return {
+				state: read(s.qualityGovernor.qualityState),
+				overrides: read(s.qualityGovernor.qualityOverrides),
+				baseline: read(s.sceneBudget.qualityBaseline),
+				shadowMap: r.shadowMap.enabled,
+				pixelRatio: r.getPixelRatio(),
+				bufferWidth: r.getDrawingBufferSize(new s.THREE.Vector2()).x,
+				canvasCss: r.domElement.clientWidth,
+				storedShadowPref: localStorage.getItem('shadowQuality'),
+				post: window.__postDebug ? (({ kinds, composerBufferWidth }) => ({ kinds, composerBufferWidth }))(window.__postDebug()) : null,
+				chip: document.querySelector('#quality-chip')
+					? { level: document.querySelector('#quality-chip').getAttribute('data-level'), pinned: document.querySelector('#quality-chip').getAttribute('data-pinned'), title: document.querySelector('#quality-chip').title }
+					: null
+			};
+		});
+
+	const base = await A.page.evaluate(() => {
+		const s = window.__stores;
+		s.sceneBudget.stopSceneMetrics();
+		s.qualityGovernor.governorForTest.reset();
+		return { dpr: window.devicePixelRatio, stored: localStorage.getItem('shadowQuality') };
+	});
+	const start = await snap();
+	h.check(start.state.level === 0 && start.overrides.dprScale === 1 && !start.overrides.shadowsOff, `boots at full quality (${JSON.stringify(start.overrides)})`);
+	h.check(start.chip === null, 'no chip at full quality');
+	h.check(start.shadowMap === true, 'premise: the renderer draws shadows at full quality');
+
+	// ---- 1. a light scene on a slow machine is never governed --------------------------
+	const light = await A.page.evaluate(() => {
+		const g = window.__gov;
+		g.metrics({ objects: 12, meshes: 12, triangles: 144, calls: 24 });
+		g.frames(400, 4000);
+		return g.decide();
+	});
+	h.check(light.level === 0 && light.moved === null, `400ms frames on a 12-box scene change nothing (${JSON.stringify(light)})`);
+
+	// ---- 2. a heavy slow scene: the first step --------------------------------------------
+	// heavy by DRAW CALLS alone (objects green): the case where the governor's own shadows
+	// step could talk 26-G out of a scene — the one section 3 is about
+	const HEAVY = { objects: 1000, meshes: 1000, triangles: 60000, calls: 4800 };
+	const first = await A.page.evaluate((m) => {
+		const g = window.__gov;
+		g.metrics(m);
+		g.frames(50, 2200);
+		return g.decide();
+	}, HEAVY);
+	h.check(first.moved === 'up' && first.level === 1, `50ms frames on a heavy scene take ONE step (${JSON.stringify(first)})`);
+	await A.page.waitForTimeout(400);
+	const afterFirst = await snap();
+	h.check(afterFirst.overrides.shadowsOff === true && afterFirst.overrides.dprScale === 1, `the first step is SHADOWS (26-E: calls are the cost) (${JSON.stringify(afterFirst.overrides)})`);
+	h.check(afterFirst.shadowMap === false, 'the renderer really stopped drawing shadows');
+	h.check(
+		afterFirst.storedShadowPref === base.stored,
+		`…without touching the user's saved shadow preference (stored ${afterFirst.storedShadowPref} === ${base.stored})`
+	);
+	h.check(afterFirst.baseline?.calls === 4800 && afterFirst.baseline?.objects === 1000, `the pre-reduction readings are recorded (${JSON.stringify(afterFirst.baseline)})`);
+	h.check(afterFirst.chip?.level === '1' && /shadows off/i.test(afterFirst.chip?.title ?? ''), `the chip appears and names what was reduced (${JSON.stringify(afterFirst.chip)})`);
+
+	// ---- 3. the 26-G interaction --------------------------------------------------------
+	// the SAME scene as the governor has made it: same objects, shadows off halved the calls
+	// to green — by its LIVE readings this scene is light
+	const guard = await A.page.evaluate(() => {
+		const s = window.__stores;
+		const g = window.__gov;
+		g.metrics({ objects: 1000, meshes: 1000, triangles: 30000, calls: 1900 });
+		const liveOnly = s.sceneBudget.isHeavy(s.sceneBudget.sceneMetrics ? g.read(s.sceneBudget.sceneMetrics) : {}, 'desktop', null);
+		const guardSays = s.overloadGuard.sceneIsHeavy();
+		let paused = null;
+		for (let i = 0; i < 12; i++) s.overloadGuard.noteFrameForFreeze(300);
+		paused = g.read(s.overloadGuard.renderPaused);
+		s.overloadGuard.resumeRendering();
+		return { liveOnly, guardSays, paused };
+	});
+	h.check(guard.liveOnly === false, 'premise: by its live readings alone the reduced scene is NOT heavy');
+	h.check(guard.guardSays === true, "26-G still judges the scene by what it cost BEFORE the governor reduced it");
+	h.check(!!guard.paused, `…so a frozen streak still pauses rendering (${JSON.stringify(guard.paused)})`);
+	// a scene that really shrank (under 70% of the baseline objects) is not held heavy
+	const shrunk = await A.page.evaluate(() => {
+		const s = window.__stores;
+		window.__gov.metrics({ objects: 400, meshes: 400, triangles: 5000, calls: 800 });
+		return s.overloadGuard.sceneIsHeavy();
+	});
+	h.check(shrunk === false, 'a scene that really shrank is not held heavy by a stale baseline');
+	await A.page.evaluate((m) => window.__gov.metrics(m), HEAVY);
+	await A.page.waitForTimeout(3500); // the resume grace, so nothing below re-pauses
+
+	// ---- 4. every step reaches its consumer, and walking back restores it ---------------
+	const top = await A.page.evaluate(async () => {
+		const s = window.__stores;
+		s.qualityGovernor.governorForTest.setLevel(s.qualityGovernor.governorForTest.level() + 100);
+		await new Promise((r) => setTimeout(r, 800));
+		return true;
+	});
+	void top;
+	const atTop = await snap();
+	h.check(
+		atTop.overrides.dprScale === 0.5 && atTop.overrides.aoOff && atTop.overrides.postOff && atTop.overrides.particlesCapped && atTop.overrides.presenceSlow,
+		`the last level holds every step (${JSON.stringify(atTop.overrides)})`
+	);
+	h.check(
+		Math.abs(atTop.pixelRatio - base.dpr * 0.5) < 1e-6,
+		`the renderer's pixel ratio follows the resolution step (${atTop.pixelRatio} = ${base.dpr} x 0.5)`
+	);
+	h.check(
+		Math.abs(atTop.bufferWidth - Math.round(atTop.canvasCss * base.dpr * 0.5)) <= 1,
+		`…so the drawing buffer really is half size (${atTop.bufferWidth}px for ${atTop.canvasCss} CSS px)`
+	);
+	h.check(
+		start.post?.kinds?.includes('ao') && !atTop.post?.kinds?.includes('ao'),
+		`the AO pass really leaves the compiled chain (${JSON.stringify(start.post?.kinds)} -> ${JSON.stringify(atTop.post?.kinds)})`
+	);
+	h.check(
+		Math.abs((atTop.post?.composerBufferWidth ?? 0) - atTop.bufferWidth) <= 1 && atTop.post.composerBufferWidth < start.post.composerBufferWidth,
+		`the composer's buffer follows the resolution step, not just the canvas (${start.post?.composerBufferWidth} -> ${atTop.post?.composerBufferWidth}px)`
+	);
+	await A.page.evaluate(async () => {
+		window.__stores.qualityGovernor.governorForTest.setLevel(0);
+		await new Promise((r) => setTimeout(r, 800));
+	});
+	const back = await snap();
+	h.check(
+		back.state.level === 0 && Math.abs(back.pixelRatio - base.dpr) < 1e-6 && back.shadowMap === true && back.baseline === null,
+		`walking back restores everything exactly (dpr ${back.pixelRatio}, shadows ${back.shadowMap}, baseline ${JSON.stringify(back.baseline)})`
+	);
+	h.check(
+		back.post?.kinds?.includes('ao') && back.post?.composerBufferWidth === start.post?.composerBufferWidth,
+		`…including AO and the composer size (${JSON.stringify(back.post)})`
+	);
+	h.check(back.chip === null, 'the chip leaves at full quality');
+
+	// ---- 5. recovery, pin/release, opt-out ----------------------------------------------
+	const recovery = await A.page.evaluate((m) => {
+		const g = window.__gov;
+		g.metrics(m);
+		g.frames(50, 2200);
+		const up = g.decide();
+		g.frames(16.7, 9000);
+		const early = g.decide();
+		g.frames(16.7, 1600);
+		const down = g.decide();
+		return { up: up.moved, early: early.moved, down: down.moved, level: down.level };
+	}, HEAVY);
+	h.check(recovery.up === 'up' && recovery.early === null && recovery.down === 'down' && recovery.level === 0, `recovers after 10s of good frames and not before (${JSON.stringify(recovery)})`);
+
+	await A.page.evaluate(() => {
+		const g = window.__gov;
+		g.frames(50, 3200);
+		g.decide();
+	});
+	await A.page.waitForTimeout(300);
+	await A.page.evaluate(() => document.querySelector('#quality-chip').click());
+	await A.page.waitForTimeout(200);
+	const pinned = await A.page.evaluate(() => {
+		const g = window.__gov;
+		g.frames(16.7, 25000);
+		const d = g.decide();
+		return { d, chip: document.querySelector('#quality-chip')?.getAttribute('data-pinned') };
+	});
+	h.check(pinned.chip === 'true' && pinned.d.level === 1 && pinned.d.moved === null, `a click on the chip HOLDS the level through good frames (${JSON.stringify(pinned)})`);
+	await A.page.evaluate(() => document.querySelector('#quality-chip').click());
+	await A.page.waitForTimeout(300);
+	const released = await snap();
+	h.check(released.state.level === 0 && released.chip === null && released.shadowMap === true, 'a second click restores full quality');
+	const snoozed = await A.page.evaluate(() => {
+		const g = window.__gov;
+		g.frames(50, 3200);
+		return g.decide();
+	});
+	h.check(snoozed.level === 0, `…and it STICKS: no automatic step during the release snooze (${JSON.stringify(snoozed)})`);
+
+	const off = await A.page.evaluate(() => {
+		const s = window.__stores;
+		s.qualityGovernor.governorForTest.reset(); // clears the snooze
+		s.qualityGovernor.setAutoQuality(false);
+		const g = window.__gov;
+		g.frames(50, 3200);
+		const d = g.decide();
+		const stored = localStorage.getItem('autoQuality');
+		s.qualityGovernor.setAutoQuality(true);
+		localStorage.removeItem('autoQuality');
+		return { level: d.level, stored };
+	});
+	h.check(off.level === 0 && off.stored === 'false', `turning it off stops it and is remembered locally (${JSON.stringify(off)})`);
+	// the real entry point: Settings binds the same store
+	await A.page.evaluate(() => window.__stores.settingsOpen.set(true));
+	await A.page.waitForTimeout(500);
+	await A.page.locator('#settings-search').fill('heavy');
+	await A.page.waitForTimeout(400);
+	const box = A.page.locator('#auto-quality');
+	const found = (await box.count()) > 0 && (await box.isVisible());
+	const had = found ? await box.isChecked() : null;
+	if (found) await box.click();
+	await A.page.waitForTimeout(250);
+	const afterSetting = await A.page.evaluate(() => ({
+		store: window.__gov.read(window.__stores.qualityGovernor.autoQuality),
+		stored: localStorage.getItem('autoQuality')
+	}));
+	if (found) await box.click();
+	await A.page.waitForTimeout(250);
+	const restoredSetting = await A.page.evaluate(() => {
+		const on = window.__gov.read(window.__stores.qualityGovernor.autoQuality);
+		localStorage.removeItem('autoQuality');
+		window.__stores.settingsOpen.set(false);
+		return on;
+	});
+	h.check(
+		found && had === true && afterSetting.store === false && afterSetting.stored === 'false' && restoredSetting === true,
+		`Settings > "Reduce quality when the scene is heavy" drives the same switch (found ${found}, checked ${had}, then ${JSON.stringify(afterSetting)}, back ${restoredSetting})`
+	);
+	await A.page.waitForTimeout(400);
+
+	// ---- 6. the ingest draw gap ----------------------------------------------------------
+	const gap = await A.page.evaluate(async () => {
+		const s = window.__stores;
+		const g = window.__gov;
+		const r = g.read(s.globalRenderer);
+		s.qualityGovernor.governorForTest.reset();
+		const framesIn = async (ms) => {
+			const a = r.info.render.frame;
+			await new Promise((res) => setTimeout(res, ms));
+			return r.info.render.frame - a;
+		};
+		const normal = await framesIn(1000);
+		// a big batch draining through slow frames
+		g.metrics({ objects: 200, meshes: 200, triangles: 3000, calls: 400, ingestBacklog: 800 });
+		s.beginSceneBatch();
+		try {
+			g.frames(50, 2200);
+			g.decide();
+			const engaged = g.read(s.qualityGovernor.ingestDrawGap);
+			const throttled = await framesIn(2000);
+			// the throttled frames are FAST; the gap must not switch itself off on them
+			g.frames(16.7, 2200);
+			g.decide();
+			const sticky = g.read(s.qualityGovernor.ingestDrawGap);
+			// render() calls, not display frames: the composer makes several per frame, so the
+			// claim is the RATIO against the same counter a second earlier
+			return { normal, engaged, throttledPerSec: throttled / 2, ratio: throttled / 2 / Math.max(1, normal), sticky, stillLevel: g.read(s.qualityGovernor.qualityState).level };
+		} finally {
+			s.endSceneBatch();
+			g.decide();
+		}
+	});
+	const gapAfter = await A.page.evaluate(() => window.__gov.read(window.__stores.qualityGovernor.ingestDrawGap));
+	h.check(gap.normal > 30, `premise: the renderer draws at display rate normally (${gap.normal} render() calls in 1s)`);
+	h.check(gap.engaged === 250, `a draining batch through slow frames engages the draw gap (${gap.engaged}ms)`);
+	h.check(
+		gap.throttledPerSec > 0 && gap.ratio < 0.15,
+		`…and the renderer really draws ~4 frames a second of 60 (${gap.throttledPerSec} render() calls/s against ${gap.normal}, ratio ${gap.ratio.toFixed(3)})`
+	);
+	h.check(gap.sticky === 250, 'the gap is sticky for the drain: its own cheap frames do not switch it off');
+	h.check(gap.stillLevel === 0, 'a light scene receiving objects is not a quality step, only a drain');
+	h.check(gapAfter === 0, 'the drain ends, the gap ends');
+
+	// ---- 7. end to end on real frames --------------------------------------------------
+	const real = await A.page.evaluate(async () => {
+		const s = window.__stores;
+		const read = window.__gov.read;
+		s.qualityGovernor.governorForTest.reset();
+		// OFF while the scene is built and measured at full quality, so "before" is clean
+		s.qualityGovernor.setAutoQuality(false);
+		s.sceneBudget.startSceneMetrics();
+		await window.__stress.seedCubes(3000);
+		window.__stress.frameAll(3000);
+		await new Promise((r) => setTimeout(r, 2500));
+		const before = s.sceneBudget.sampleSceneMetrics();
+		const beforeRun = await window.__stress.frames(2000);
+		s.qualityGovernor.setAutoQuality(true);
+		localStorage.removeItem('autoQuality');
+		// let it act: steps are held 3s apart
+		const deadline = performance.now() + 20000;
+		while (performance.now() < deadline && read(s.qualityGovernor.qualityState).level === 0) await new Promise((r) => setTimeout(r, 250));
+		const engagedAfterMs = Math.round(20000 - (deadline - performance.now()));
+		await new Promise((r) => setTimeout(r, 2500));
+		const after = s.sceneBudget.sampleSceneMetrics();
+		const afterRun = await window.__stress.frames(2000);
+		const pct = (d) => {
+			const x = [...d].sort((a, b) => a - b);
+			return x[Math.min(x.length - 1, Math.ceil(0.95 * x.length) - 1)];
+		};
+		const state = read(s.qualityGovernor.qualityState);
+		return {
+			engagedAfterMs,
+			state,
+			beforeCalls: before.calls,
+			afterCalls: after.calls,
+			beforeP95: pct(beforeRun.deltas),
+			afterP95: pct(afterRun.deltas),
+			heavyStill: s.overloadGuard.sceneIsHeavy()
+		};
+	});
+	console.log('real 3,000 boxes: ' + JSON.stringify(real));
+	h.check(real.beforeP95 > 35, `premise: 3,000 real boxes miss 30fps on this GPU (p95 ${real.beforeP95}ms)`);
+	h.check(real.state.level >= 1, `the governor engaged ON ITS OWN from real frames (level ${real.state.level} after ${real.engagedAfterMs}ms: ${real.state.labels.join(', ')})`);
+	h.check(real.afterCalls < real.beforeCalls * 0.75, `…and the measured draw calls fell (${real.beforeCalls} -> ${real.afterCalls})`);
+	h.check(real.heavyStill === true, '…while 26-G still judges the scene heavy');
+
+	await A.page.evaluate(() => {
+		window.__stores.qualityGovernor.governorForTest.reset();
+	});
+	h.check(h.pageErrors(A).length === 0, `no page errors (${JSON.stringify(h.pageErrors(A))})`);
+	await h.finish(browser);
+});
diff --git a/tests/e2e/scene-stress.cjs b/tests/e2e/scene-stress.cjs
new file mode 100644
index 00000000..d4cb0ca5
--- /dev/null
+++ b/tests/e2e/scene-stress.cjs
@@ -0,0 +1,256 @@
+// 26-E — THE SCENE-STRESS RIG (roadmap 26 section 6). A MEASUREMENT, run by hand.
+//
+//   APP_URL=https://theprototype.app:5180/ node tests/e2e/scene-stress.cjs \
+//       [--sizes 100,1000,3000,10000] [--dense 1,5,15] [--dense-tris 200000] \
+//       [--physics 100,300,1000] [--sync 1000,3000] [--window 4000] \
+//       [--view shaded-ao|shaded] [--out path.md]
+//
+// NOT a .test.cjs on purpose: a full sweep runs for many minutes. `npm run e2e --
+// scene-stress` runs the small REGRESSION suite instead (scene-stress.test.cjs), which
+// drives the same probe (sceneStressProbe.cjs) at a tiny size.
+//
+// WHY IT EXISTS: roadmap 26 section 2's budget numbers were starting points reasoned from
+// WebGL practice. The governor (26-D) and the auto-stops (26-G) steer by them, so they
+// have to be MEASURED. Per scene size this records:
+//   - seed / import cost and the long tasks it caused
+//   - frame p50/p95/p99 idle and while ORBITING (navigation is when a heavy scene hurts)
+//   - draw calls and triangles per DISPLAY frame (see sceneBudget's render-totals note —
+//     the raw `renderer.info` reads one fullscreen pass and cannot be used)
+//   - GPU proxies (geometries/textures) and the JS heap
+//   - object-list render ms (and whether 26-B windowed it)
+//   - one autosave export: ms and bytes
+//   - optionally, physics over the same scene: body count, step p50/p95, whether 26-G's
+//     slow-step stop fired
+//   - optionally, a second peer JOINING: time-to-synced as the joiner's own
+//     `syncMs` reads it (announcement -> last object landed), plus the joiner's long tasks
+//
+// CAVEATS worth printing with every table:
+//   - the numbers belong to ONE GPU; the report names it (WEBGL_debug_renderer_info). A
+//     SwiftShader row (no GPU) measures the CPU rasteriser, not the app — the rig refuses
+//     to treat one as data and says so.
+//   - headless Chromium has no compositor pressure from other windows; a real desktop is
+//     worse, never better.
+//   - the two-peer sync uses whatever signaling the helpers use (PEER_CONFIG). It is ONE
+//     joiner and one handshake — not a flood.
+
+const fs = require('fs');
+const path = require('path');
+const h = require('./helpers.cjs');
+const { measureScene, installProbe, summarize } = require('./sceneStressProbe.cjs');
+
+const argv = process.argv.slice(2);
+/** @param {string} name @param {string} fallback */
+function arg(name, fallback) {
+	const i = argv.indexOf('--' + name);
+	return i >= 0 && argv[i + 1] != null ? argv[i + 1] : fallback;
+}
+/** @param {string} value */
+const list = (value) =>
+	value
+		.split(',')
+		.map((n) => parseInt(n, 10))
+		.filter((n) => Number.isFinite(n) && n > 0);
+
+const SIZES = list(arg('sizes', '100,1000,3000,10000'));
+const DENSE = list(arg('dense', '1,5,15'));
+const DENSE_TRIS = parseInt(arg('dense-tris', '200000'), 10);
+const PHYSICS = list(arg('physics', ''));
+const SYNC = list(arg('sync', ''));
+const WINDOW_MS = parseInt(arg('window', '4000'), 10);
+const VIEW = arg('view', '');
+const OUT = arg('out', '');
+const storage = VIEW ? { viewMode: VIEW } : undefined;
+
+/** @param {any} x @param {number} [d] */
+const r = (x, d = 1) => (x == null || !Number.isFinite(Number(x)) ? '—' : Number(Number(x).toFixed(d)));
+
+/**
+ * A second peer joins a host already holding `size` boxes. The joiner's own `syncMs`
+ * metric (commandsHandler, 26-E) is the answer: announcement to last object, measured on
+ * one clock.
+ * @param {any} browser @param {number} size
+ */
+async function measureSync(browser, size) {
+	const host = await h.setupPage(browser, 'host-' + size, { storage });
+	const joiner = await h.setupPage(browser, 'join-' + size, { storage });
+	try {
+		await installProbe(host.page);
+		await installProbe(joiner.page);
+		await host.page.evaluate((n) => window.__stress.seedCubes(n), size);
+		const t0 = Date.now();
+		await joiner.page.evaluate(() => (window.__stress.joinStarted = performance.now()));
+		await h.connect(joiner, host, 0);
+		// wait for the joiner to hold the scene AND for its batch to have closed
+		const deadline = Date.now() + 240000;
+		/** @type {any} */
+		let got = null;
+		while (Date.now() < deadline) {
+			got = await joiner.page.evaluate(() => ({
+				count: window.__stress.count(),
+				sync: window.__stores.commandsHandler.lastSyncStats(),
+				tasks: window.__stress.tasksSince(window.__stress.joinStarted)
+			}));
+			if (got.sync && got.count >= size) break;
+			await joiner.page.waitForTimeout(250);
+		}
+		return {
+			size,
+			wallMs: Date.now() - t0,
+			objects: got?.count ?? 0,
+			syncMs: got?.sync?.complete ? got.sync.ms : null,
+			complete: !!got?.sync?.complete,
+			joinerLongTasks: got?.tasks?.count ?? null,
+			joinerLongestTask: got?.tasks ? Math.round(got.tasks.longest) : null,
+			joinerBusyMs: got?.tasks ? Math.round(got.tasks.busy) : null
+		};
+	} finally {
+		await host.ctx.close();
+		await joiner.ctx.close();
+	}
+}
+
+/** @param {any[]} rows @param {any[]} dense @param {any[]} physics @param {any[]} sync */
+function report(rows, dense, physics, sync) {
+	const gpu = rows[0]?.gpu ?? dense[0]?.gpu ?? physics[0]?.gpu ?? 'unknown';
+	const L = [];
+	L.push('# 26-E — scene stress, measured');
+	L.push('');
+	L.push('GPU: `' + gpu + '`  ·  window ' + WINDOW_MS + 'ms per reading  ·  1280x720  ·  view ' + (VIEW || 'default'));
+	if (/swiftshader|llvmpipe|software/i.test(gpu))
+		L.push('\n**WARNING: software rasteriser — these rows measure the CPU renderer, not the app. Do not fold them into the budget.**');
+	L.push('');
+	L.push('## Boxes (the real `/create box` path)');
+	L.push('');
+	L.push('| objects | seed ms | seed longest task | idle p50/p95/p99 | orbit p50/p95/p99 | orbit long tasks | calls/frame | tris/frame | renders/frame | geoms | textures | heap MB | list ms (rows, mode) | autosave ms / MB |');
+	L.push('|---|---|---|---|---|---|---|---|---|---|---|---|---|---|');
+	for (const w of rows) {
+		L.push(
+			'| ' + w.objects +
+				' | ' + r(w.seedMs, 0) +
+				' | ' + r(w.seedLongestTask, 0) +
+				' | ' + r(w.idle.p50) + ' / ' + r(w.idle.p95) + ' / ' + r(w.idle.p99) +
+				' | ' + r(w.orbit.p50) + ' / ' + r(w.orbit.p95) + ' / ' + r(w.orbit.p99) +
+				' | ' + w.orbitLongTasks + ' (max ' + r(w.orbitLongestTask, 0) + ')' +
+				' | ' + r(w.calls, 0) +
+				' | ' + r(w.triangles, 0) +
+				' | ' + r(w.rendersPerFrame) +
+				' | ' + r(w.geometries, 0) +
+				' | ' + r(w.textures, 0) +
+				' | ' + r(w.heapMB, 0) +
+				' | ' + r(w.listMs, 0) + ' (' + w.listRows + ', ' + w.listMode + ')' +
+				' | ' + r(w.autosaveExportMs, 0) + ' / ' + r((w.autosaveBytes ?? 0) / 1048576, 2) +
+				(w.autosaveError ? ' ERR' : '') +
+				' |'
+		);
+	}
+	if (dense.length) {
+		L.push('');
+		L.push('## Dense models (a ' + DENSE_TRIS + '-triangle GLB through the real import path)');
+		L.push('');
+		L.push('| models | import p50/max ms | import longest task | idle p50/p95/p99 | orbit p50/p95/p99 | tris/frame | calls/frame | heap MB | autosave ms / MB |');
+		L.push('|---|---|---|---|---|---|---|---|---|');
+		for (const w of dense) {
+			L.push(
+				'| ' + w.objects +
+					' | ' + r(w.importMsP50, 0) + ' / ' + r(w.importMsMax, 0) +
+					' | ' + r(w.importLongestTask, 0) +
+					' | ' + r(w.idle.p50) + ' / ' + r(w.idle.p95) + ' / ' + r(w.idle.p99) +
+					' | ' + r(w.orbit.p50) + ' / ' + r(w.orbit.p95) + ' / ' + r(w.orbit.p99) +
+					' | ' + r(w.triangles, 0) +
+					' | ' + r(w.calls, 0) +
+					' | ' + r(w.heapMB, 0) +
+					' | ' + r(w.autosaveExportMs, 0) + ' / ' + r((w.autosaveBytes ?? 0) / 1048576, 2) +
+					' |'
+			);
+		}
+	}
+	if (physics.length) {
+		L.push('');
+		L.push('## Physics over N dynamic boxes (26-G stops a run at ' + '30 steps over 24ms)');
+		L.push('');
+		L.push('| boxes | bodies | step p50 / p95 ms | frame p50/p95 while simulating | auto-stopped |');
+		L.push('|---|---|---|---|---|');
+		for (const w of physics) {
+			L.push(
+				'| ' + w.size +
+					' | ' + (w.physicsAutoStopped ? 'stopped' : r(w.bodies, 0)) +
+					' | ' + r(w.stepP50) + ' / ' + r(w.stepP95) +
+					' | ' + (w.physicsFrame ? r(w.physicsFrame.p50) + ' / ' + r(w.physicsFrame.p95) : '—') +
+					' | ' + (w.physicsStarted ? (w.physicsAutoStopped ? 'YES' : 'no') : 'did not start') +
+					' |'
+			);
+		}
+	}
+	if (sync.length) {
+		L.push('');
+		L.push('## A joiner receiving the scene (two peers, one handshake)');
+		L.push('');
+		L.push('| objects | joiner syncMs | wall ms (dial -> synced) | joiner long tasks | longest | busy ms |');
+		L.push('|---|---|---|---|---|---|');
+		for (const w of sync) {
+			L.push(
+				'| ' + w.objects + '/' + w.size +
+					' | ' + (w.complete ? r(w.syncMs, 0) : 'INCOMPLETE') +
+					' | ' + r(w.wallMs, 0) +
+					' | ' + r(w.joinerLongTasks, 0) +
+					' | ' + r(w.joinerLongestTask, 0) +
+					' | ' + r(w.joinerBusyMs, 0) +
+					' |'
+			);
+		}
+	}
+	L.push('');
+	L.push('```json');
+	L.push(JSON.stringify({ rows, dense, physics, sync }, null, 1));
+	L.push('```');
+	return L.join('\n');
+}
+
+(async () => {
+	// precise-memory: without it performance.memory is bucketed and every size reads the same heap
+	const browser = await h.launch({ args: [...h.GPU_ARGS, '--enable-precise-memory-info'] });
+	const rows = [];
+	const dense = [];
+	const physics = [];
+	const sync = [];
+	try {
+		for (const size of SIZES) {
+			console.log('\n==== ' + size + ' boxes ====');
+			const row = await measureScene(h, browser, { kind: 'cubes', size, windowMs: WINDOW_MS, storage });
+			console.log(JSON.stringify({ ...row, gpu: undefined }));
+			rows.push(row);
+		}
+		for (const size of DENSE) {
+			console.log('\n==== ' + size + ' dense models ====');
+			const row = await measureScene(h, browser, { kind: 'dense', size, windowMs: WINDOW_MS, denseTris: DENSE_TRIS, storage });
+			console.log(JSON.stringify({ ...row, gpu: undefined }));
+			dense.push(row);
+		}
+		for (const size of PHYSICS) {
+			console.log('\n==== physics over ' + size + ' boxes ====');
+			const row = await measureScene(h, browser, { kind: 'cubes', size, windowMs: WINDOW_MS, physics: true, autosave: false, storage });
+			console.log(JSON.stringify({ bodies: row.bodies, stepP50: row.stepP50, stepP95: row.stepP95, stopped: row.physicsAutoStopped, frame: row.physicsFrame }));
+			physics.push(row);
+		}
+		for (const size of SYNC) {
+			console.log('\n==== a joiner receiving ' + size + ' boxes ====');
+			const row = await measureSync(browser, size);
+			console.log(JSON.stringify(row));
+			sync.push(row);
+		}
+		const md = report(rows, dense, physics, sync);
+		console.log('\n' + md.split('```json')[0]);
+		if (OUT) {
+			const out = path.isAbsolute(OUT) ? OUT : path.resolve(process.cwd(), OUT);
+			fs.mkdirSync(path.dirname(out), { recursive: true });
+			fs.writeFileSync(out, md);
+			console.log('written to ' + out);
+		}
+	} catch (err) {
+		console.error('STRESS RUN FAILED:', err && err.stack ? err.stack : err);
+		process.exitCode = 1;
+	} finally {
+		await browser.close();
+	}
+	void summarize;
+})();
diff --git a/tests/e2e/scene-stress.test.cjs b/tests/e2e/scene-stress.test.cjs
new file mode 100644
index 00000000..34df9e67
--- /dev/null
+++ b/tests/e2e/scene-stress.test.cjs
@@ -0,0 +1,202 @@
+// 26-E — the scene-stress rig's REGRESSION suite (roadmap 26 section 6).
+//
+// `scene-stress.cjs` is the measurement rig, run by hand; this proves the machinery it
+// stands on still measures what it says:
+//   1. the percentile rule the rig reports is the meter's rule (pure, no browser)
+//   2. THE FINDING: draw calls and triangles are counted per DISPLAY frame across every
+//      `renderer.render()` — the raw `renderer.info` reads one fullscreen pass (1 call,
+//      1 triangle with 150 boxes on screen), so the triangle and draw-call budgets could
+//      never leave green
+//   3. stopping the sampler hands the renderer back unwrapped, and starting re-wraps it
+//   4. the metric sources the rig needed are registered from their own modules: physics
+//      bodies + step time, autosave export ms/bytes, and the receive-side sync time
+//   4b. a loading stall is measured from the last ARRIVAL, not the announcement (the rig
+//      found a 3,000-object join declared dead at 63s while still landing)
+//   5. the rig's per-size runner produces a COMPLETE row end to end at a tiny size, so
+//      the manual rig cannot rot unnoticed between the runs that feed the roadmap
+//
+// Run: APP_URL=https://theprototype.app:5180/ npm run e2e -- scene-stress
+const h = require('./helpers.cjs');
+const { percentile, summarize, installProbe, measureScene } = require('./sceneStressProbe.cjs');
+
+h.run(async () => {
+	// ---- 1. the pure part --------------------------------------------------------------
+	const ring = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100];
+	h.check(percentile(ring, 0.5) === 50 && percentile(ring, 0.95) === 100, `nearest-rank percentiles (p50 ${percentile(ring, 0.5)}, p95 ${percentile(ring, 0.95)})`);
+	const s = summarize([5, 1, NaN, 3]);
+	h.check(s.n === 3 && s.p50 === 3 && s.max === 5, `summarize sorts, drops non-numbers and reports max (${JSON.stringify(s)})`);
+	h.check(summarize([]).p95 === null, 'an empty window reports null, never a zero that reads as a fast frame');
+
+	// GPU args: frame-time and per-frame render totals over real frames (the e2e skill's rule)
+	const browser = await h.launch({ args: h.GPU_ARGS });
+	const A = await h.setupPage(browser, 'A');
+	const gpu = await installProbe(A.page);
+	console.log('renderer: ' + gpu);
+
+	// the meter's own rule, on the same numbers, in the page
+	const meterRule = await A.page.evaluate((values) => {
+		const b = window.__stores.sceneBudget;
+		for (let i = 0; i < 300; i++) b.noteFrame(1000); // push the ring out of the way
+		for (const v of values) for (let i = 0; i < 24; i++) b.noteFrame(v);
+		return b.frameStats();
+	}, ring);
+	h.check(
+		meterRule.p50 === percentile([...ring.flatMap((v) => Array(24).fill(v))], 0.5) &&
+			meterRule.p95 === percentile([...ring.flatMap((v) => Array(24).fill(v))], 0.95),
+		`the rig's percentile is the meter's percentile (meter p50 ${meterRule.p50} p95 ${meterRule.p95})`
+	);
+
+	// ---- 2. per-frame render totals ----------------------------------------------------
+	const seeded = await A.page.evaluate(() => window.__stress.seedCubes(150));
+	h.check(seeded.count === 150, `premise: 150 real boxes in the scene (${seeded.count})`);
+	await A.page.evaluate(() => window.__stress.frameAll(150));
+	const totals = await A.page.evaluate(async () => {
+		const { sceneBudget, globalRenderer } = window.__stores;
+		let r;
+		globalRenderer.subscribe((/** @type {any} */ v) => (r = v))();
+		await new Promise((res) => setTimeout(res, 1200));
+		const m = sceneBudget.sampleSceneMetrics();
+		// what one reader of renderer.info sees at an arbitrary moment: the last pass
+		const lastPass = { calls: r.info.render.calls, triangles: r.info.render.triangles };
+		return { calls: m.calls, triangles: m.triangles, rendersPerFrame: m.rendersPerFrame, lastPass, wrapped: !!r.__budgetRender };
+	});
+	h.check(totals.wrapped, 'the sampler wraps the live renderer');
+	h.check(
+		totals.rendersPerFrame > 1,
+		`premise: a desktop frame is SEVERAL render() calls, not one (${totals.rendersPerFrame} per frame)`
+	);
+	h.check(
+		totals.lastPass.calls < 150,
+		`premise: raw renderer.info reads only the last pass (${totals.lastPass.calls} calls, ${totals.lastPass.triangles} triangles)`
+	);
+	h.check(totals.calls >= 150, `draw calls per frame count every box (${totals.calls} for 150 boxes)`);
+	h.check(totals.triangles >= 150 * 12, `triangles per frame count every box (${totals.triangles} >= ${150 * 12})`);
+
+	// more objects must move the reading — the axis is live, not a constant
+	await A.page.evaluate(() => window.__stress.seedCubes(150));
+	await A.page.evaluate(() => window.__stress.frameAll(300));
+	const doubled = await A.page.evaluate(async () => {
+		await new Promise((res) => setTimeout(res, 1200));
+		return window.__stores.sceneBudget.sampleSceneMetrics();
+	});
+	h.check(
+		doubled.calls > totals.calls * 1.5 && doubled.triangles > totals.triangles * 1.5,
+		`doubling the boxes roughly doubles the reading (calls ${totals.calls} -> ${doubled.calls}, tris ${totals.triangles} -> ${doubled.triangles})`
+	);
+
+	// ---- 3. stop hands the renderer back, start re-wraps ------------------------------
+	const cycle = await A.page.evaluate(async () => {
+		const { sceneBudget, globalRenderer } = window.__stores;
+		let r;
+		globalRenderer.subscribe((/** @type {any} */ v) => (r = v))();
+		// three defines `render` as an OWN property in its constructor, so "restored" means the
+		// very same function object is back, not that the property is gone
+		const original = r.__budgetRender;
+		sceneBudget.stopSceneMetrics();
+		const stopped = { wrapped: !!r.__budgetRender, same: !!original && r.render === original };
+		sceneBudget.startSceneMetrics();
+		await new Promise((res) => setTimeout(res, 800));
+		return { stopped, restarted: !!r.__budgetRender };
+	});
+	h.check(!cycle.stopped.wrapped && cycle.stopped.same, `stopping the sampler restores the renderer's own render (${JSON.stringify(cycle.stopped)})`);
+	h.check(cycle.restarted, 'starting it again re-wraps the renderer');
+
+	// ---- 4. the metric sources ---------------------------------------------------------
+	const save = await A.page.evaluate(async () => {
+		await window.__stores.autosave.saveNow();
+		const m = window.__stores.sceneBudget.sampleSceneMetrics();
+		return { exportMs: m.autosaveExportMs, bytes: m.autosaveBytes };
+	});
+	h.check(save.exportMs > 0 && save.bytes > 1000, `autosave export ms and bytes reach the sampler (${save.exportMs}ms, ${save.bytes} bytes)`);
+
+	const phys = await A.page.evaluate(async () => {
+		const { physics, sceneBudget } = window.__stores;
+		const before = sceneBudget.sampleSceneMetrics();
+		const run = await window.__stress.physics(1500);
+		const after = sceneBudget.sampleSceneMetrics();
+		return { beforeBodies: before.bodies, beforeStep: before.physicsStepMs, run, afterBodies: after.bodies, afterStep: after.physicsStepMs, stats: physics.physicsStepStats() };
+	});
+	h.check(phys.beforeBodies === 0 && phys.beforeStep === null, `no simulation: 0 bodies and no step time (${phys.beforeBodies}, ${phys.beforeStep})`);
+	h.check(phys.run.startedOk, 'premise: the simulation started');
+	h.check(phys.run.bodies === 300, `while simulating the sampler counts the bodies (${phys.run.bodies} for 300 dynamic boxes)`);
+	h.check(phys.run.step && phys.run.step.n > 20 && phys.run.step.p95 > 0, `…and the step time (${JSON.stringify(phys.run.step)})`);
+	h.check(
+		phys.afterBodies === 0 && phys.afterStep === null && phys.stats === null,
+		`a stopped run reads as no run, never a stale cost (${phys.afterBodies}, ${phys.afterStep})`
+	);
+
+	const sync = await A.page.evaluate(async () => {
+		const { commandsHandler, sceneBudget } = window.__stores;
+		// a batch that FINISHES: every announced uuid counted as arrived
+		await commandsHandler.createLoader(2, ['stress-a', 'stress-b'], 'nobody');
+		await new Promise((res) => setTimeout(res, 300));
+		commandsHandler.noteLoadFailed(['stress-a', 'stress-b']);
+		const finished = { stats: commandsHandler.lastSyncStats(), metric: sceneBudget.sampleSceneMetrics().syncMs };
+		// a batch that is CLOSED before it finishes (the sender left, a scene clear)
+		await commandsHandler.createLoader(2, ['stress-c', 'stress-d'], 'nobody');
+		await new Promise((res) => setTimeout(res, 100));
+		commandsHandler.clearLoadingBatch();
+		const closed = { stats: commandsHandler.lastSyncStats(), metric: sceneBudget.sampleSceneMetrics().syncMs };
+		return { finished, closed };
+	});
+	h.check(
+		sync.finished.stats?.complete === true && sync.finished.metric >= 280 && sync.finished.stats.objects === 2,
+		`a finished batch reports its sync time, on one clock (${JSON.stringify(sync.finished)})`
+	);
+	h.check(
+		sync.closed.stats?.complete === false && sync.closed.metric === null,
+		`a batch closed before it finished reports NO sync time, not a fast one (${JSON.stringify(sync.closed)})`
+	);
+	// ---- 4b. a stall is SILENCE, not duration ------------------------------------------
+	// The rig's finding: the 60s stall timer was armed once at the announcement, so a
+	// 3,000-object join still landing ~10 objects a second was declared dead at 63s. Here
+	// the stall is 800ms and the batch keeps making progress past it.
+	const stall = await A.page.evaluate(async () => {
+		const { commandsHandler, loading } = window.__stores;
+		const read = () => {
+			let v;
+			loading.subscribe((/** @type {any} */ x) => (v = x))();
+			return v.length;
+		};
+		const sleep = (/** @type {number} */ ms) => new Promise((r) => setTimeout(r, ms));
+		commandsHandler.setLoadingStallMsForTest(800);
+		try {
+			await commandsHandler.createLoader(4, ['st-1', 'st-2', 'st-3', 'st-4'], 'nobody');
+			const trace = [];
+			// one arrival every 500ms: total 1.5s, never 800ms of silence
+			for (const uuid of ['st-1', 'st-2', 'st-3']) {
+				await sleep(500);
+				commandsHandler.noteLoadFailed([uuid]);
+				trace.push(read());
+			}
+			const aliveAfter1500 = read();
+			// …then silence: the stall must still fire
+			await sleep(1300);
+			return { trace, aliveAfter1500, afterSilence: read(), sync: commandsHandler.lastSyncStats() };
+		} finally {
+			commandsHandler.setLoadingStallMsForTest();
+		}
+	});
+	h.check(
+		stall.aliveAfter1500 === 1,
+		`a batch still arriving past the stall window is NOT given up on (${JSON.stringify(stall.trace)} left after 1.5s)`
+	);
+	h.check(
+		stall.afterSilence === 0 && stall.sync?.complete === false,
+		`…and real silence still ends it, reported as incomplete (${stall.afterSilence} left, ${JSON.stringify(stall.sync)})`
+	);
+
+	h.check(h.pageErrors(A).length === 0, `no page errors (${JSON.stringify(h.pageErrors(A))})`);
+	await A.ctx.close();
+
+	// ---- 5. the rig's runner, end to end, at a tiny size -------------------------------
+	const row = await measureScene(h, browser, { kind: 'cubes', size: 40, windowMs: 1000, physics: true });
+	const numeric = ['seedMs', 'objects', 'triangles', 'calls', 'rendersPerFrame', 'geometries', 'textures', 'listMs', 'autosaveExportMs', 'autosaveBytes', 'bodies', 'stepP95'];
+	const missing = numeric.filter((key) => !Number.isFinite(row[key]));
+	h.check(missing.length === 0, `the rig produces a complete row (missing: ${JSON.stringify(missing)})`);
+	h.check(row.idle.n > 20 && row.orbit.n > 20 && row.idle.p95 > 0, `…with real frame windows (idle ${row.idle.n} frames, orbit ${row.orbit.n})`);
+	h.check(row.objects === 40 && row.listRows === 40 && row.bodies === 40, `…measuring the scene it built (${row.objects} objects, ${row.listRows} rows, ${row.bodies} bodies)`);
+	h.check(row.pageErrors === 0, `…with no page errors (${row.pageErrors})`);
+
+	await h.finish(browser);
+});
diff --git a/tests/e2e/sceneStressProbe.cjs b/tests/e2e/sceneStressProbe.cjs
new file mode 100644
index 00000000..569da473
--- /dev/null
+++ b/tests/e2e/sceneStressProbe.cjs
@@ -0,0 +1,340 @@
+// 26-E — THE SCENE-STRESS PROBE, shared by the manual rig and its regression suite.
+//
+// `scene-stress.cjs` is the measurement rig (a many-minute sweep, run by hand, like
+// `net-stress.cjs`). `scene-stress.test.cjs` is the quick regression that proves the rig
+// still measures what it says it measures. Both drive THIS file, so the suite covers the
+// real measurement code rather than a copy of it that can drift.
+//
+// Everything that is timed is timed INSIDE the page. A CDP round trip is several
+// milliseconds on this box, which is a third of a frame — a frame time measured across
+// the bridge is a measurement of the bridge.
+//
+// Not a `.test.cjs`, so the runner never picks it up on its own.
+
+/**
+ * Nearest-rank percentile — the SAME rule `sceneBudget.frameStats` uses, so a number the
+ * rig reports and a number the meter reports mean the same thing. PURE.
+ * @param {number[]} sorted ascending @param {number} q 0..1
+ */
+function percentile(sorted, q) {
+	if (!sorted.length) return null;
+	const index = Math.min(sorted.length - 1, Math.max(0, Math.ceil(q * sorted.length) - 1));
+	return sorted[index];
+}
+
+/** @param {number[]} values */
+function summarize(values) {
+	const sorted = [...values].filter(Number.isFinite).sort((a, b) => a - b);
+	return {
+		n: sorted.length,
+		p50: percentile(sorted, 0.5),
+		p95: percentile(sorted, 0.95),
+		p99: percentile(sorted, 0.99),
+		max: sorted.length ? sorted[sorted.length - 1] : null
+	};
+}
+
+/**
+ * Install `window.__stress` in the page. Idempotent. Returns the renderer string, so a
+ * report can say what GPU its numbers came from (they are meaningless without it).
+ * @param {any} page
+ */
+async function installProbe(page) {
+	return page.evaluate(() => {
+		/** @type {any} */
+		const w = window;
+		const s = w.__stores;
+		/** @param {any} store */
+		const read = (store) => {
+			let v;
+			store.subscribe((/** @type {any} */ x) => (v = x))();
+			return v;
+		};
+		/** @param {number} ms */
+		const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+		const nextFrame = () => new Promise((r) => requestAnimationFrame(r));
+
+		if (!w.__stress) {
+			/** @type {any} */
+			const ns = (w.__stress = { tasks: [] });
+			try {
+				ns.observer = new PerformanceObserver((list) => {
+					for (const e of list.getEntries()) ns.tasks.push({ at: e.startTime, ms: e.duration });
+				});
+				ns.observer.observe({ entryTypes: ['longtask'] });
+				ns.longTasksAvailable = true;
+			} catch {
+				ns.longTasksAvailable = false;
+			}
+
+			/** Long tasks that STARTED inside [from, now]. */
+			ns.tasksSince = (/** @type {number} */ from) => {
+				const hit = ns.tasks.filter((/** @type {any} */ t) => t.at >= from);
+				return {
+					count: hit.length,
+					longest: hit.reduce((m, /** @type {any} */ t) => Math.max(m, t.ms), 0),
+					busy: hit.reduce((m, /** @type {any} */ t) => m + t.ms, 0)
+				};
+			};
+
+			/** Frame deltas for `ms`, optionally doing `each(dt)` every frame. */
+			ns.frames = async (/** @type {number} */ ms, /** @type {any} */ each) => {
+				/** @type {number[]} */
+				const deltas = [];
+				const started = performance.now();
+				let last = await nextFrame();
+				while (performance.now() - started < ms) {
+					const now = /** @type {number} */ (await nextFrame());
+					deltas.push(now - last);
+					if (each) each(now - last);
+					last = now;
+				}
+				return { deltas, tasks: ns.tasksSince(started), elapsed: performance.now() - started };
+			};
+
+			ns.renderer = () => {
+				const r = read(s.globalRenderer);
+				try {
+					const gl = r.getContext();
+					const dbg = gl.getExtension('WEBGL_debug_renderer_info');
+					return dbg ? gl.getParameter(dbg.UNMASKED_RENDERER_WEBGL) : gl.getParameter(gl.RENDERER);
+				} catch {
+					return 'unknown';
+				}
+			};
+
+			ns.count = () => read(s.objectsGroup)?.children?.length ?? 0;
+
+			/**
+			 * Seed `n` boxes through the REAL create command (history, palette colour,
+			 * shadow defaults, the poke) laid out on a square grid so every one is in
+			 * frame. In chunks, yielding between them, because the thing being measured
+			 * is the scene afterwards — not how badly a 10,000-iteration loop blocks.
+			 */
+			ns.seedCubes = async (/** @type {number} */ n, /** @type {number} */ chunk = 250) => {
+				const started = performance.now();
+				const side = Math.ceil(Math.sqrt(n));
+				const gap = 1.6;
+				const base = ns.count();
+				for (let i = 0; i < n; i++) {
+					s.commandsHandler.sceneCommand('/create box');
+					const o = read(s.selectedObject);
+					if (o?.position) o.position.set((i % side) * gap - (side * gap) / 2, 0.5, Math.floor(i / side) * gap - (side * gap) / 2);
+					if (i % chunk === chunk - 1) await sleep(0);
+				}
+				// the creations are synchronous, but the palette/shadow sweeps ride pokes
+				for (let t = 0; t < 200 && ns.count() < base + n; t++) await sleep(50);
+				s.selectedObjects?.set?.([]);
+				s.flushScenePokes?.();
+				await nextFrame();
+				return { ms: performance.now() - started, tasks: ns.tasksSince(started), count: ns.count() - base };
+			};
+
+			/** Point the editor camera at the whole grid, from above and to one side. */
+			ns.frameAll = (/** @type {number} */ n) => {
+				const side = Math.ceil(Math.sqrt(Math.max(1, n))) * 1.6;
+				const cam = read(s.globalCamera);
+				const controls = read(s.orbitControls);
+				const d = Math.max(12, side * 0.9);
+				cam.position.set(d * 0.6, d * 0.7, d * 0.8);
+				cam.far = Math.max(cam.far, d * 6);
+				cam.updateProjectionMatrix();
+				controls?.target?.set?.(0, 0, 0);
+				controls?.update?.();
+			};
+
+			/** A continuous orbit: what "the scene is heavy" feels like while navigating. */
+			ns.orbit = (/** @type {number} */ ms) => {
+				const controls = read(s.orbitControls);
+				return ns.frames(ms, () => {
+					if (controls?._rotateLeft) controls._rotateLeft(0.02);
+					else if (controls?.rotateLeft) controls.rotateLeft(0.02);
+					controls?.update?.();
+				});
+			};
+
+			/** The budget sampler's own reading, after it has seen at least one window. */
+			ns.metrics = async () => {
+				await sleep(600);
+				return s.sceneBudget.sampleSceneMetrics();
+			};
+
+			/** One autosave snapshot through the real writer. */
+			ns.autosave = async () => {
+				const started = performance.now();
+				await s.autosave.saveNow();
+				const status = read(s.autosave.autosaveStatus);
+				return {
+					wallMs: performance.now() - started,
+					exportMs: status.lastExportMs,
+					bytes: status.lastBytes,
+					error: status.lastError,
+					tasks: ns.tasksSince(started)
+				};
+			};
+
+			/**
+			 * Object list: close it, reopen it, and time until rows are in the DOM plus
+			 * one painted frame. Above 500 rows 26-B windows the list, so the row count is
+			 * reported too — a small count at 10k is the virtualisation working.
+			 */
+			ns.listRender = async () => {
+				s.objectListClose.set(true);
+				for (let t = 0; t < 40 && document.querySelector('#object-tree [role="treeitem"]'); t++) await sleep(25);
+				await nextFrame();
+				const started = performance.now();
+				s.objectListClose.set(false);
+				let rows = 0;
+				for (let t = 0; t < 400; t++) {
+					rows = document.querySelectorAll('#object-tree [role="treeitem"]').length;
+					if (rows > 0) break;
+					await new Promise((r) => setTimeout(r, 0));
+				}
+				await nextFrame();
+				return { ms: performance.now() - started, rows, mode: document.querySelector('[data-object-rows]')?.getAttribute('data-object-rows') ?? null };
+			};
+
+			/**
+			 * Import a dense model through the real GLB import path: a UV sphere of about
+			 * `tris` triangles, exported to binary glTF in the page, handed to
+			 * `fileHandler.importFile`. Timed until the object is in the scene.
+			 */
+			ns.importDense = async (/** @type {number} */ tris) => {
+				const THREE = s.THREE;
+				const Exporter = s.GLTFExporterModule.GLTFExporter;
+				// a UV sphere of w x h segments has about 2*w*(h-1) triangles
+				const h = Math.max(4, Math.round(Math.sqrt(tris / 2)));
+				const wSeg = Math.max(4, Math.round(tris / (2 * (h - 1))));
+				const mesh = new THREE.Mesh(new THREE.SphereGeometry(1, wSeg, h), new THREE.MeshStandardMaterial({ color: 0x8899aa }));
+				mesh.name = 'dense';
+				const glb = await new Promise((resolve, reject) =>
+					new Exporter().parse(mesh, resolve, reject, { binary: true })
+				);
+				mesh.geometry.dispose();
+				const file = new File([/** @type {any} */ (glb)], 'dense.glb', { type: 'model/gltf-binary' });
+				const before = ns.count();
+				const started = performance.now();
+				await s.fileHandler.importFile(file, 'dense', 'glb', [ (before % 6) * 2.5 - 6, 1, Math.floor(before / 6) * 2.5 - 6 ]);
+				for (let t = 0; t < 600 && ns.count() <= before; t++) await sleep(20);
+				s.selectedObjects?.set?.([]);
+				return { ms: performance.now() - started, bytes: /** @type {any} */ (glb).byteLength, landed: ns.count() > before, tasks: ns.tasksSince(started) };
+			};
+
+			/** Run the simulation over what is in the scene for `ms`. */
+			ns.physics = async (/** @type {number} */ ms) => {
+				const physics = s.physics;
+				if (!read(physics.simulating)) await physics.toggleSimulation();
+				for (let t = 0; t < 100 && !read(physics.simulating); t++) await sleep(50);
+				const startedOk = !!read(physics.simulating);
+				await sleep(400); // the first steps build the world
+				const run = await ns.frames(ms);
+				const step = physics.physicsStepStats?.() ?? null;
+				const metrics = s.sceneBudget.sampleSceneMetrics();
+				const stillRunning = !!read(physics.simulating);
+				if (stillRunning) physics.stopSimulation();
+				return { startedOk, stillRunning, step, bodies: metrics.bodies ?? null, run };
+			};
+		}
+		return w.__stress.renderer();
+	});
+}
+
+/**
+ * The per-size measurement, on a FRESH page so one size's heap and GPU state never
+ * colours the next. Returns one report row. Every field is a number or null; nothing is
+ * a string that a table would have to parse.
+ * @param {any} h helpers.cjs
+ * @param {any} browser
+ * @param {{kind: 'cubes'|'dense', size: number, windowMs?: number, physics?: boolean, autosave?: boolean, denseTris?: number, storage?: Record<string,string>, viewport?: {width: number, height: number}}} opts
+ */
+async function measureScene(h, browser, opts) {
+	const windowMs = opts.windowMs ?? 4000;
+	const peer = await h.setupPage(browser, opts.kind + '-' + opts.size, {
+		context: { viewport: opts.viewport ?? { width: 1280, height: 720 } },
+		storage: opts.storage
+	});
+	try {
+		const gpu = await installProbe(peer.page);
+		/** @type {any} */
+		const row = { kind: opts.kind, size: opts.size, gpu };
+		const emptyIdle = await peer.page.evaluate((ms) => window.__stress.frames(ms), Math.min(2000, windowMs));
+		row.emptyFrame = summarize(emptyIdle.deltas);
+
+		if (opts.kind === 'cubes') {
+			const seed = await peer.page.evaluate((n) => window.__stress.seedCubes(n), opts.size);
+			row.seedMs = Math.round(seed.ms);
+			row.seedLongTasks = seed.tasks.count;
+			row.seedLongestTask = Math.round(seed.tasks.longest);
+			row.objects = seed.count;
+			await peer.page.evaluate((n) => window.__stress.frameAll(n), opts.size);
+		} else {
+			const tris = opts.denseTris ?? 200000;
+			/** @type {number[]} */
+			const imports = [];
+			let bytes = 0;
+			let landed = 0;
+			let longest = 0;
+			for (let i = 0; i < opts.size; i++) {
+				const one = await peer.page.evaluate((t) => window.__stress.importDense(t), tris);
+				imports.push(one.ms);
+				bytes = one.bytes;
+				if (one.landed) landed++;
+				longest = Math.max(longest, one.tasks.longest);
+			}
+			row.importMsP50 = Math.round(summarize(imports).p50 ?? 0);
+			row.importMsMax = Math.round(summarize(imports).max ?? 0);
+			row.importLongestTask = Math.round(longest);
+			row.glbBytes = bytes;
+			row.objects = landed;
+			await peer.page.evaluate(() => window.__stress.frameAll(36));
+		}
+		await peer.page.waitForTimeout(1200);
+
+		const idle = await peer.page.evaluate((ms) => window.__stress.frames(ms), windowMs);
+		row.idle = summarize(idle.deltas);
+		row.idleLongTasks = idle.tasks.count;
+		const orbit = await peer.page.evaluate((ms) => window.__stress.orbit(ms), windowMs);
+		row.orbit = summarize(orbit.deltas);
+		row.orbitLongTasks = orbit.tasks.count;
+		row.orbitLongestTask = Math.round(orbit.tasks.longest);
+
+		const m = await peer.page.evaluate(() => window.__stress.metrics());
+		row.triangles = m.triangles;
+		row.calls = m.calls;
+		row.rendersPerFrame = m.rendersPerFrame ?? null;
+		row.geometries = m.geometries;
+		row.textures = m.textures;
+		row.heapMB = m.heap ? Math.round(m.heap / 1048576) : null;
+		row.meterP95 = m.frameP95;
+
+		const list = await peer.page.evaluate(() => window.__stress.listRender());
+		row.listMs = Math.round(list.ms);
+		row.listRows = list.rows;
+		row.listMode = list.mode;
+
+		if (opts.autosave !== false) {
+			const save = await peer.page.evaluate(() => window.__stress.autosave());
+			row.autosaveExportMs = save.exportMs ? Math.round(save.exportMs) : null;
+			row.autosaveWallMs = Math.round(save.wallMs);
+			row.autosaveBytes = save.bytes || null;
+			row.autosaveLongestTask = Math.round(save.tasks.longest);
+			row.autosaveError = save.error || null;
+		}
+
+		if (opts.physics) {
+			const run = await peer.page.evaluate((ms) => window.__stress.physics(ms), windowMs);
+			row.physicsStarted = run.startedOk;
+			row.physicsAutoStopped = run.startedOk && !run.stillRunning;
+			row.bodies = run.bodies;
+			row.stepP50 = run.step ? Math.round(run.step.p50 * 10) / 10 : null;
+			row.stepP95 = run.step ? Math.round(run.step.p95 * 10) / 10 : null;
+			row.physicsFrame = summarize(run.run.deltas);
+		}
+		row.pageErrors = h.pageErrors(peer).length;
+		return row;
+	} finally {
+		await peer.ctx.close();
+	}
+}
+
+module.exports = { percentile, summarize, installProbe, measureScene };
diff --git a/tests/unit/qualityGovernor.test.js b/tests/unit/qualityGovernor.test.js
new file mode 100644
index 00000000..45508121
--- /dev/null
+++ b/tests/unit/qualityGovernor.test.js
@@ -0,0 +1,192 @@
+import { describe, it, expect } from 'vitest';
+import {
+	createGovernor,
+	overridesAt,
+	stepLabelsAt,
+	GOVERNOR_STEPS,
+	MAX_LEVEL,
+	FULL_QUALITY,
+	drawGapFor,
+	INGEST_DRAW_GAP_MS
+} from '../../src/lib/qualityGovernorCore.js';
+
+/**
+ * feed `ms`-long frames from `from` for `durationMs`; returns the time reached
+ * @param {ReturnType<typeof createGovernor>} gov @param {number} from @param {number} durationMs @param {number} ms
+ */
+function run(gov, from, durationMs, ms) {
+	let t = from;
+	while (t < from + durationMs) {
+		t += ms;
+		gov.noteFrame(ms, t);
+	}
+	return t;
+}
+
+describe('overridesAt', () => {
+	it('level 0 is full quality and every level is the sum of the steps before it', () => {
+		expect(overridesAt(0)).toEqual(FULL_QUALITY);
+		expect(overridesAt(1)).toEqual({ ...FULL_QUALITY, shadowsOff: true });
+		const top = overridesAt(MAX_LEVEL);
+		expect(top.dprScale).toBe(0.5);
+		expect(top.shadowsOff && top.aoOff && top.postOff && top.particlesCapped && top.presenceSlow).toBe(true);
+	});
+	it('a later resolution step replaces an earlier one, never compounds it', () => {
+		const at = GOVERNOR_STEPS.findIndex((s) => s.key === 'res72') + 1;
+		expect(overridesAt(at).dprScale).toBe(0.72);
+	});
+	it('SHADOWS come first: 26-E measured draw calls, not fill, as the cost', () => {
+		expect(GOVERNOR_STEPS[0].key).toBe('shadows');
+	});
+	it('clamps silly levels and names every step in effect', () => {
+		expect(overridesAt(-3)).toEqual(FULL_QUALITY);
+		expect(overridesAt(999)).toEqual(overridesAt(MAX_LEVEL));
+		expect(stepLabelsAt(2)).toEqual([GOVERNOR_STEPS[0].label, GOVERNOR_STEPS[1].label]);
+	});
+});
+
+describe('createGovernor', () => {
+	it('a slow HEAVY scene steps down once, then holds', () => {
+		const g = createGovernor();
+		let t = run(g, 0, 2100, 50);
+		expect(g.decide(t, { heavy: true }).moved).toBe('up');
+		expect(g.level()).toBe(1);
+		// the very next moment: no fresh window, no second step
+		t = run(g, t, 500, 50);
+		expect(g.decide(t, { heavy: true }).moved).toBe(null);
+		// after the hold with frames still slow: the next step
+		t = run(g, t, 2600, 50);
+		expect(g.decide(t, { heavy: true }).moved).toBe('up');
+		expect(g.level()).toBe(2);
+	});
+	it('the hitch a change itself causes is not evidence for the next step', () => {
+		const g = createGovernor();
+		let t = run(g, 0, 2100, 50);
+		expect(g.decide(t, { heavy: true }).moved).toBe('up');
+		// the recompile right after the step: a burst of slow frames and THREE long tasks —
+		// more than the long-task trigger allows, still inside its 5s window at the next
+		// decision, so without the settle window this alone would take another step
+		t = run(g, t, 500, 120);
+		g.noteLongTask(t - 400);
+		g.noteLongTask(t - 250);
+		g.noteLongTask(t - 100);
+		// then the reduced scene runs at a steady 30fps
+		t = run(g, t, 2600, 33.4);
+		expect(g.decide(t, { heavy: true }).moved).toBe(null);
+		expect(g.level()).toBe(1);
+	});
+	it('a slow LIGHT scene is never governed (the 26-G ruling: a slow machine is not an overloaded scene)', () => {
+		const g = createGovernor();
+		const t = run(g, 0, 5000, 400);
+		expect(g.decide(t, { heavy: false }).moved).toBe(null);
+		expect(g.level()).toBe(0);
+	});
+	it('a steady 30fps is NOT overloaded: vsync quantises it to 33.3-33.4ms (26-E)', () => {
+		const g = createGovernor();
+		let t = 0;
+		for (let i = 0; i < 150; i++) {
+			const ms = i % 2 ? 33.4 : 33.3;
+			t += ms;
+			g.noteFrame(ms, t);
+		}
+		expect(g.decide(t, { heavy: true }).moved).toBe(null);
+	});
+	it('a smooth heavy scene is left alone', () => {
+		const g = createGovernor();
+		const t = run(g, 0, 5000, 16.7);
+		expect(g.decide(t, { heavy: true }).moved).toBe(null);
+	});
+	it('decides nothing on a window that is not full yet', () => {
+		const g = createGovernor();
+		const t = run(g, 0, 600, 60);
+		expect(g.decide(t, { heavy: true }).moved).toBe(null);
+	});
+	it('long tasks alone can trigger a step', () => {
+		const g = createGovernor();
+		const t = run(g, 0, 3100, 16.7);
+		for (const at of [t - 3000, t - 2000, t - 1000]) g.noteLongTask(at);
+		const d = g.decide(t, { heavy: true });
+		expect(d.moved).toBe('up');
+		expect(d.reason).toBe('long tasks');
+	});
+	it('recovers one step after 10s of good frames, and not before', () => {
+		const g = createGovernor();
+		let t = run(g, 0, 2100, 50);
+		g.decide(t, { heavy: true });
+		t = run(g, t, 9000, 16.7);
+		expect(g.decide(t, { heavy: true }).moved).toBe(null);
+		t = run(g, t, 1500, 16.7);
+		expect(g.decide(t, { heavy: true }).moved).toBe('down');
+		expect(g.level()).toBe(0);
+	});
+	it('a PINNED level never walks back', () => {
+		const g = createGovernor();
+		let t = run(g, 0, 2100, 50);
+		g.decide(t, { heavy: true });
+		t = run(g, t, 20000, 16.7);
+		expect(g.decide(t, { heavy: true, pinned: true }).moved).toBe(null);
+		expect(g.level()).toBe(1);
+	});
+	it('a scene that becomes light is handed back without waiting for good frames', () => {
+		const g = createGovernor();
+		let t = run(g, 0, 2100, 50);
+		g.decide(t, { heavy: true });
+		t = run(g, t, 10500, 60);
+		expect(g.decide(t, { heavy: false }).reason).toBe('scene is light');
+	});
+	it('FLAPPING doubles the next recovery hold, and a later honest step resets it', () => {
+		const g = createGovernor();
+		let t = run(g, 0, 2100, 50);
+		g.decide(t, { heavy: true }); // up
+		t = run(g, t, 10500, 16.7);
+		g.decide(t, { heavy: true }); // down
+		// a walk down is a change too: the next step still waits out the 3s hold
+		t = run(g, t, 3100, 50);
+		expect(g.decide(t, { heavy: true }).moved).toBe('up'); // back up within 20s
+		expect(g.recoverHoldMs()).toBe(20000);
+		t = run(g, t, 10500, 16.7);
+		expect(g.decide(t, { heavy: true }).moved).toBe(null); // 10s is no longer enough
+		t = run(g, t, 10000, 16.7);
+		expect(g.decide(t, { heavy: true }).moved).toBe('down');
+		// much later, a heavier scene: not a flap
+		t = run(g, t + 60000, 2100, 50);
+		expect(g.decide(t, { heavy: true }).moved).toBe('up');
+		expect(g.recoverHoldMs()).toBe(10000);
+	});
+	it('forget() discards the evidence (a hidden tab, a pause)', () => {
+		const g = createGovernor();
+		const t = run(g, 0, 2100, 50);
+		g.forget();
+		expect(g.decide(t, { heavy: true }).moved).toBe(null);
+	});
+	it('never climbs past the last step', () => {
+		const g = createGovernor();
+		let t = 0;
+		for (let i = 0; i < MAX_LEVEL + 3; i++) {
+			t = run(g, t, 3100, 50);
+			g.decide(t, { heavy: true });
+		}
+		expect(g.level()).toBe(MAX_LEVEL);
+	});
+	it('uses the VR thresholds on the vr profile', () => {
+		const g = createGovernor();
+		const t = run(g, 0, 2100, 16.7);
+		expect(g.decide(t, { heavy: true, profile: 'vr' }).moved).toBe('up');
+	});
+});
+
+describe('drawGapFor (the ingest rule)', () => {
+	const base = { engaged: false, draining: true, backlog: 500, p95: 50 };
+	it('throttles drawing while a big batch drains through slow frames', () => {
+		expect(drawGapFor(base)).toBe(INGEST_DRAW_GAP_MS);
+	});
+	it('leaves a fast frame, a small backlog, or no drain alone', () => {
+		expect(drawGapFor({ ...base, p95: 16.7 })).toBe(0);
+		expect(drawGapFor({ ...base, backlog: 10 })).toBe(0);
+		expect(drawGapFor({ ...base, draining: false })).toBe(0);
+	});
+	it('is STICKY for the drain: throttled frames are cheap, and must not switch it off', () => {
+		expect(drawGapFor({ ...base, engaged: true, p95: 5, backlog: 1 })).toBe(INGEST_DRAW_GAP_MS);
+		expect(drawGapFor({ ...base, engaged: true, draining: false })).toBe(0);
+	});
+});