diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 496f60fdb..170e924b0 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -5,11 +5,11 @@
 # enforced by whoever remembered to run it, and a broken main was discovered at release
 # time. Everything below is what a maintainer already does by hand.
 #
-# WHY e2e-smoke IS NOT REQUIRED YET: it renders WebGL through SwiftShader on a GPU-less
-# runner, and this project's own notes measure ~4.5 fps there plus a documented family of
-# timing-sensitive suites. Blocking every PR on that before it has been observed green on
-# GitHub would train people to ignore a red tick, which is worse than not having it. It
-# reports, it does not gate, and the comment below says when to flip it.
+# e2e-smoke GATES since test-health-1 (feat/60). It renders WebGL through SwiftShader on a
+# GPU-less runner (~4.5 fps), so it was report-only until it had been seen green on GitHub:
+# the runner step now really fails (it used to `|| echo` every red away), a failed suite runs
+# once more (green on the retry = flaky, reported), and a known flake is entered in
+# tests/e2e/quarantine.json with an owner and a review date instead of blocking every PR.
 #
 # Two-peer suites stay a MANUAL gate: they meet on the self-hosted signaling box, which a
 # public runner cannot reach and should not be pointed at.
@@ -150,9 +150,7 @@ jobs:
 
   e2e-smoke:
     runs-on: ubuntu-latest
-    # NOT a gate yet — see the header. Flip this to false once it has been green on a few
-    # PRs in a row; until then a red here is a signal to read, not a block.
-    continue-on-error: true
+    # a gate — see the header (green on GitHub for bc453ae8 and e77ca3f7 before the flip)
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-node@v4
@@ -180,14 +178,20 @@ jobs:
           # Deliberately NOT added: net-stress and signaling-reconnect are multi-peer and
           # meet on the self-hosted signaling box, which a public runner cannot reach and
           # should not be pointed at (see the header) — they stay a manual gate.
-          for s in net-backoff net-mesh wire-hardening runtime-resilience diagnostics mesh-budget script-guard dispose approval-timeout; do
-            echo "::group::$s"
-            npm run e2e -- "$s" || echo "SUITE FAILED: $s"
-            echo "::endgroup::"
-          done
+          # test-health-1: through the battery runner, so a red is a red (the old loop's
+          # `|| echo SUITE FAILED` could never fail the step), a failed suite runs once more
+          # (green on the retry = flaky, reported) and tests/e2e/quarantine.json applies.
+          node scripts/ci/battery.cjs run --only net-backoff,net-mesh,wire-hardening,runtime-resilience,diagnostics,mesh-budget,script-guard,dispose,approval-timeout --port 5173 --out /tmp/smoke
       - name: dev server log on failure
         if: failure()
         run: tail -40 /tmp/dev.log
+      - name: suite logs
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: e2e-smoke-logs
+          path: /tmp/smoke/logs
+          if-no-files-found: ignore
 
   # 53-reader (A4): THE ACCESSIBILITY GATE. axe-core over the main surfaces (editor shell, object
   # list, Inspector, Settings, Asset Browser on recorded fixtures, phone shell) FAILS on serious and
@@ -230,6 +234,13 @@ jobs:
       - name: dev server log on failure
         if: failure()
         run: tail -40 /tmp/dev.log
+      - name: suite logs
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: e2e-smoke-logs
+          path: /tmp/smoke/logs
+          if-no-files-found: ignore
 
   # 38 (NOTES-38 #18): THE TOKEN SCREENSHOT DIFF. /kit renders every redesign primitive in every
   # state; this job shoots it in the dark, light and custom themes on the PR's BASE ref and on its
diff --git a/check-baseline.json b/check-baseline.json
index b7dfe7ec8..c512987b8 100644
--- a/check-baseline.json
+++ b/check-baseline.json
@@ -1,6 +1,6 @@
 {
 	"comment": "27-I: the svelte-check floor, read ONLY by scripts/check-ratchet.cjs. It used to be hardcoded in release.yml's shell block, where it went stale (362 while the tree measured 359). Ratchet it DOWN whenever a change legitimately removes errors - that is the project convention, and --update does it in one command.",
-	"errors": 299,
+	"errors": 288,
 	"warnings": 39,
-	"measured": "2026-10-11"
+	"measured": "2026-10-24"
 }
diff --git a/perf/budgets.json b/perf/budgets.json
index ef7734fc2..737962320 100644
--- a/perf/budgets.json
+++ b/perf/budgets.json
@@ -16,10 +16,10 @@
 		"textureMB": 64
 	},
 	"targets": {
-		"comment": "46 B1/B2 — the editor's budget chip and Statistics ▸ Budget judge a scene against ONE of these (picked in the chip's menu, LOCAL). Quest's four gated metrics are `defaults` above and are NOT repeated here (perfBudget.cjs refuses a copy, so the chip and the gate cannot disagree); the gate never reads this block. shadowLights / shadowCasters are meter-only rows; shadowCasters counts shadow DRAWS (casters x shadow lights) and is held to the draw-call budget, since every one is a call. Phone and desktop are starting values, not gated: phone = sceneBudget's measured VR/mobile green ceilings, desktop = 26-E's measured desktop green ceilings (owed on device).",
+		"comment": "46 B1/B2 — the editor's budget chip and Statistics ▸ Budget judge a scene against ONE of these (picked in the chip's menu, LOCAL). Quest's four gated metrics are `defaults` above and are NOT repeated here (perfBudget.cjs refuses a copy, so the chip and the gate cannot disagree); the gate never reads this block. shadowLights / shadowCasters are meter-only rows; shadowCasters counts shadow DRAWS (casters x shadow lights) and is held to the draw-call budget, since every one is a call. Phone and desktop are starting values, not gated: phone = sceneBudget's measured VR/mobile green ceilings, desktop = 26-E's measured desktop green ceilings (owed on device) test-health-1 (2026-10-24) reconciled them with cloud plans/core/pending/research/quest-phone-perf.md §1: phone = its MID phone row (calls 100-150 [3P] -> 150, shadow draws held to that; 500k triangles, 256 MB, one shadow map already inside it), desktop texture memory 512 -> 1024 MB (its 1-2 GB [U]). Quest is unchanged: 150 calls is inside <200 [M] / 100-150 [3P], and its triangles / texture MB are STRICTER than the research's [U] web estimates (500-750k, <=512 MB), which say measure on device.",
 		"quest": { "label": "Quest / VR", "short": "Quest", "shadowLights": 1, "shadowCasters": 150 },
-		"phone": { "label": "Phone", "short": "Phone", "calls": 300, "triangles": 500000, "lights": 3, "textureMB": 256, "shadowLights": 1, "shadowCasters": 300 },
-		"desktop": { "label": "Desktop", "short": "Desktop", "calls": 2000, "triangles": 4000000, "lights": 8, "textureMB": 512, "shadowLights": 4, "shadowCasters": 2000 }
+		"phone": { "label": "Phone", "short": "Phone", "calls": 150, "triangles": 500000, "lights": 3, "textureMB": 256, "shadowLights": 1, "shadowCasters": 150 },
+		"desktop": { "label": "Desktop", "short": "Desktop", "calls": 2000, "triangles": 4000000, "lights": 8, "textureMB": 1024, "shadowLights": 4, "shadowCasters": 2000 }
 	},
 	"games": {},
 	"levels": {},
diff --git a/scripts/ci/battery.cjs b/scripts/ci/battery.cjs
index f994cf223..f4c6d6c77 100755
--- a/scripts/ci/battery.cjs
+++ b/scripts/ci/battery.cjs
@@ -4,9 +4,10 @@
 // The battery is the list an integrator runs before a release: tests/e2e/battery.json holds it
 // (suite → seconds measured on a GitHub runner, or twice the desk time until one has run), the
 // suites a public runner must skip (`skip`: they need the self-hosted signaling box, a hosts-file
-// origin or a built app) and the ones that run but do not gate (`optional`: red or flaky on
-// SwiftShader with the same red on the unchanged base — the reason is on the line). Nothing here
-// names a suite; the list is data, refreshed from the integrators' battery runs (`refresh`).
+// origin or a built app). What runs but does not gate is tests/e2e/quarantine.json (test-health-1:
+// it replaced battery.json's suite-wide `optional` map) — per CHECK, with an owner and a review date,
+// read through scripts/ci/quarantine.cjs. Nothing here names a suite; the list is data, refreshed from
+// the integrators' battery runs (`refresh`).
 //
 //   node scripts/ci/battery.cjs plan                      # matrix JSON for GITHUB_OUTPUT
 //   node scripts/ci/battery.cjs run --shard 3 --of 14     # run one shard (serves the app itself)
@@ -15,20 +16,22 @@
 //
 // Sharding is longest-first onto the least-loaded shard, by name on ties: every shard computes the
 // same assignment from the same file, so the plan job only has to say how many shards there are.
-// A failed suite runs once more; green on the retry = `flaky` (reported, not a red).
+// A failed suite runs once more; green on the retry = `flaky` (reported, not a red). Red twice and
+// every failed check quarantined = `quarantined` (reported in its own tier, not a red).
 
 const fs = require('fs');
 const path = require('path');
 const { spawn, spawnSync } = require('child_process');
+const quarantine = require('./quarantine.cjs');
 
 const ROOT = path.resolve(__dirname, '..', '..');
 const BATTERY = path.join(ROOT, 'tests', 'e2e', 'battery.json');
 
 /**
  * @typedef {{ comment?: string, refs: Record<string, {repo: string, ref: string}>, shards: {target_minutes: number, max: number, min: number},
- *   pc?: {games: string[], levels: string[]}, skip: Record<string, string>, optional: Record<string, string>, setup: Record<string, string>,
+ *   pc?: {games: string[], levels: string[]}, skip: Record<string, string>, setup: Record<string, string>,
  *   suites: Record<string, number> }} Battery
- * @typedef {{ name: string, status: 'pass'|'flaky'|'fail'|'timeout'|'gone', required: boolean, rc: number|null, secs: number,
+ * @typedef {{ name: string, status: 'pass'|'flaky'|'quarantined'|'fail'|'timeout'|'gone', required: boolean, rc: number|null, secs: number,
  *   retrySecs?: number, pass: number, fail: number, last: string, shard: number }} SuiteResult
  */
 
@@ -166,7 +169,7 @@ function runSuite(name, est, out, tag) {
 			fs.closeSync(log);
 			const text = fs.readFileSync(logFile, 'utf8');
 			if (timedOut) fs.appendFileSync(logFile, `\n[battery] TIMEOUT after ${timeout / 1000}s\n`);
-			resolve({ rc: timedOut ? null : code, secs: Math.round((Date.now() - t0) / 1000), timedOut, ...counts(text) });
+			resolve({ rc: timedOut ? null : code, secs: Math.round((Date.now() - t0) / 1000), timedOut, text, ...counts(text) });
 		});
 	});
 }
@@ -174,6 +177,12 @@ function runSuite(name, est, out, tag) {
 /** @param {string[]} argv */
 async function run(argv) {
 	const b = load();
+	const q = quarantine.load();
+	const qErrors = quarantine.validate(q);
+	if (qErrors.length) {
+		for (const e of qErrors) console.error('quarantine.json: ' + e);
+		process.exit(2);
+	}
 	const of = Number(opt(argv, '--of') || shardCount(b));
 	const shard = Number(opt(argv, '--shard') || 1);
 	const out = path.resolve(opt(argv, '--out') || process.env.BATTERY_OUT || path.join(ROOT, '..', 'battery-out'));
@@ -187,7 +196,7 @@ async function run(argv) {
 	const results = [];
 	console.log(`shard ${shard}/${of}: ${mine.length} suites, est ${Math.round(mine.reduce((t, s) => t + (b.suites[s] || 60), 0) / 60)} min`);
 	for (const name of mine) {
-		const required = !(name in b.optional);
+		const required = true;
 		if (!fs.existsSync(path.join(ROOT, 'tests', 'e2e', name + '.test.cjs'))) {
 			results.push({ name, status: 'gone', required: false, rc: null, secs: 0, pass: 0, fail: 0, last: 'no such suite (refresh battery.json)', shard });
 			continue;
@@ -214,10 +223,19 @@ async function run(argv) {
 			if (again.rc === 0) status = 'flaky';
 			else r = again;
 		}
-		const res = { name, status, required, rc: r.rc, secs: r.secs, retrySecs, pass: r.pass, fail: r.fail, last: r.last, shard };
+		/** @type {string[]} */
+		let quarantinedChecks = [];
+		if (status === 'fail' || status === 'timeout') {
+			const v = quarantine.classify(q, name, r.text, { timedOut: r.timedOut });
+			if (v.quarantined) {
+				status = 'quarantined';
+				quarantinedChecks = v.whole ? ['(whole suite)'] : v.failed;
+			}
+		}
+		const res = { name, status, required, rc: r.rc, secs: r.secs, retrySecs, pass: r.pass, fail: r.fail, last: quarantinedChecks.length ? 'quarantined: ' + quarantinedChecks.join(' | ').slice(0, 140) : r.last, shard };
 		results.push(res);
-		if (status === 'pass' || status === 'flaky') fs.rmSync(path.join(out, 'evidence', name), { recursive: true, force: true });
-		console.log(`${name} ${status}${required ? '' : ' (optional)'} rc=${r.rc} pass~${r.pass} fail~${r.fail} ${r.secs}s${retrySecs ? ` retry ${retrySecs}s` : ''} :: ${r.last}`);
+		if (status === 'pass' || status === 'flaky' || status === 'quarantined') fs.rmSync(path.join(out, 'evidence', name), { recursive: true, force: true });
+		console.log(`${name} ${status} rc=${r.rc} pass~${r.pass} fail~${r.fail} ${r.secs}s${retrySecs ? ` retry ${retrySecs}s` : ''} :: ${r.last}`);
 	}
 	stop(server);
 	fs.writeFileSync(path.join(out, `results-${shard}.json`), JSON.stringify({ shard, of, results }, null, 1));
@@ -232,14 +250,14 @@ async function run(argv) {
 function table(results, title) {
 	const red = results.filter((r) => r.status === 'fail' || r.status === 'timeout');
 	const req = red.filter((r) => r.required);
-	const opt = red.filter((r) => !r.required);
+	const quar = results.filter((r) => r.status === 'quarantined');
 	const flaky = results.filter((r) => r.status === 'flaky');
 	const secs = results.reduce((t, r) => t + r.secs + (r.retrySecs || 0), 0);
 	const row = (/** @type {SuiteResult} */ r) => `| ${r.name} | ${r.status} | ${r.shard} | ${r.pass}/${r.fail} | ${r.secs}s | ${r.last.replace(/\|/g, '\\|')} |`;
 	const head = '| suite | status | shard | ✓/✗ | time | last line |\n|---|---|---|---|---|---|\n';
-	let md = `### ${title}: ${results.length} suites, ${req.length} required red, ${opt.length} optional red, ${flaky.length} flaky (${Math.round(secs / 60)} suite-min)\n\n`;
+	let md = `### ${title}: ${results.length} suites, ${req.length} required red, ${quar.length} quarantined, ${flaky.length} flaky (${Math.round(secs / 60)} suite-min)\n\n`;
 	if (req.length) md += `**Required reds**\n\n${head}${req.map(row).join('\n')}\n\n`;
-	if (opt.length) md += `<details><summary>Optional reds (do not gate)</summary>\n\n${head}${opt.map(row).join('\n')}\n\n</details>\n\n`;
+	if (quar.length) md += `<details><summary>Quarantined reds (tests/e2e/quarantine.json — do not gate)</summary>\n\n${head}${quar.map(row).join('\n')}\n\n</details>\n\n`;
 	if (flaky.length) md += `<details><summary>Flaky (green on the retry)</summary>\n\n${head}${flaky.map(row).join('\n')}\n\n</details>\n\n`;
 	const gone = results.filter((r) => r.status === 'gone');
 	if (gone.length) md += `Listed but gone (refresh tests/e2e/battery.json): ${gone.map((r) => r.name).join(', ')}\n\n`;
@@ -262,6 +280,8 @@ function report(argv) {
 	const b = load();
 	const missing = Array.from({ length: of || shardCount(b) }, (_, i) => i + 1).filter((s) => !seen.has(s));
 	let md = table(all, 'e2e battery');
+	const qWarn = quarantine.warnings(quarantine.load(), all, Object.keys(b.suites));
+	if (qWarn.length) md += `<details><summary>Quarantine to review (${qWarn.length})</summary>\n\n${qWarn.map((w) => '- ' + w).join('\n')}\n\n</details>\n\n`;
 	if (missing.length) md += `**Shards with no results (crashed or cancelled): ${missing.join(', ')}**\n`;
 	if (process.env.GITHUB_STEP_SUMMARY) fs.appendFileSync(process.env.GITHUB_STEP_SUMMARY, md);
 	else console.log(md);
@@ -296,7 +316,6 @@ function write(b) {
 		`\t"shards": ${JSON.stringify(b.shards)}`,
 		`\t"pc": ${JSON.stringify(b.pc || { games: [], levels: [] })}`,
 		`\t"skip": ${obj(b.skip, '\t')}`,
-		`\t"optional": ${obj(b.optional, '\t')}`,
 		`\t"setup": ${obj(b.setup, '\t')}`,
 		`\t"suites": ${obj(b.suites, '\t')}`
 	];
@@ -329,9 +348,9 @@ function refresh(argv) {
 			for (const [n, s] of Object.entries(JSON.parse(fs.readFileSync(f, 'utf8')))) if (n in b.suites) b.suites[n] = Number(s);
 		}
 	}
-	for (const k of Object.keys(b.optional)) if (!(k in b.suites)) delete b.optional[k];
 	write(b);
-	console.log(`battery.json: ${Object.keys(b.suites).length} suites, ${Object.keys(b.skip).length} skipped, ${Object.keys(b.optional).length} optional, ${shardCount(b)} shards`);
+	console.log(`battery.json: ${Object.keys(b.suites).length} suites, ${Object.keys(b.skip).length} skipped, ${shardCount(b)} shards`);
+	for (const w of quarantine.warnings(quarantine.load(), [], Object.keys(b.suites))) console.log('warning: ' + w);
 }
 
 // ---------------------------------------------------------------- plan
diff --git a/scripts/ci/quarantine.cjs b/scripts/ci/quarantine.cjs
new file mode 100644
index 000000000..2f79f0333
--- /dev/null
+++ b/scripts/ci/quarantine.cjs
@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+// test-health-1 — THE QUARANTINE: known flaky or known-red e2e checks, by name, with an owner and a date.
+//
+// The battery (scripts/ci/battery.cjs, and the integrators' battery.sh through `triage`) gates on every
+// red EXCEPT one listed in tests/e2e/quarantine.json. It is perf/budgets.json's `allow` list one domain
+// over: an entry records a known debt, it is not a place to put a red you have not read. Every entry
+// names the suite, optionally ONE check (a substring of its `FAIL <label>` line — the label text a suite
+// passes to h.check), why it is there, who owns the fix, when it went in and when to look again.
+//
+// THE NON-BLOCKING TIER IS PER CHECK. A suite red counts as quarantined only when EVERY failed check of
+// its run matches an entry for that suite (or the suite has a whole-suite entry, `check` absent) — so a
+// quarantined timing row cannot hide a new red in the same suite. A suite that crashed (`SCRIPT FAILED`,
+// no FAIL line, no summary line) or timed out is never covered by a check entry: nothing says the
+// quarantined row is what stopped it.
+//
+// Dates warn, they never fail (the allow-list rule: a date must not turn an unrelated PR red). An entry
+// whose review date passed, or whose suite ran fully green, is printed as a warning to act on.
+//
+//   node scripts/ci/quarantine.cjs check                       # validate the file
+//   node scripts/ci/quarantine.cjs triage <summary.txt> [<logdir>]  # split a battery.sh summary's reds
+//   node scripts/ci/quarantine.cjs list                        # what is quarantined, by review date
+
+const fs = require('fs');
+const path = require('path');
+
+const ROOT = path.resolve(__dirname, '..', '..');
+const QUARANTINE = path.join(ROOT, 'tests', 'e2e', 'quarantine.json');
+const REQUIRED = ['suite', 'reason', 'owner', 'since', 'review'];
+const KEYS = [...REQUIRED, 'check'];
+const DATE = /^\d{4}-\d{2}-\d{2}$/;
+
+/**
+ * @typedef {{ suite: string, check?: string, reason: string, owner: string, since: string, review: string }} Entry
+ * @typedef {{ comment?: string, quarantine: Entry[] }} Quarantine
+ * @typedef {{ quarantined: boolean, whole: boolean, failed: string[], unmatched: string[], entries: Entry[] }} Verdict
+ */
+
+/** @returns {Quarantine} */
+function load(file = QUARANTINE) {
+	if (!fs.existsSync(file)) return { quarantine: [] };
+	return JSON.parse(fs.readFileSync(file, 'utf8'));
+}
+
+/** @param {any} q @returns {string[]} */
+function validate(q) {
+	/** @type {string[]} */
+	const errors = [];
+	if (!q || !Array.isArray(q.quarantine)) return ['quarantine must be an array'];
+	const seen = new Set();
+	q.quarantine.forEach((/** @type {any} */ e, /** @type {number} */ i) => {
+		const at = `quarantine[${i}]${e?.suite ? ' (' + e.suite + ')' : ''}`;
+		for (const k of REQUIRED) if (typeof e?.[k] !== 'string' || !e[k].trim()) errors.push(`${at}.${k} is required`);
+		for (const k of Object.keys(e ?? {})) if (!KEYS.includes(k)) errors.push(`${at}: unknown key ${k}`);
+		if ('check' in (e ?? {}) && (typeof e.check !== 'string' || !e.check.trim())) errors.push(`${at}.check must be a non-empty string (omit it for the whole suite)`);
+		for (const k of ['since', 'review']) if (e?.[k] && !DATE.test(e[k])) errors.push(`${at}.${k} must be YYYY-MM-DD`);
+		if (e?.since && e?.review && e.review <= e.since) errors.push(`${at}: review must be after since`);
+		const key = `${e?.suite}\u0000${e?.check ?? '*'}`;
+		if (seen.has(key)) errors.push(`${at}: duplicate entry`);
+		seen.add(key);
+	});
+	return errors;
+}
+
+/** the labels of the FAIL lines a suite printed (helpers.check) @param {string} log */
+function failedChecks(log) {
+	return log
+		.split('\n')
+		.map((l) => /^\s*(?:✗|FAIL|not ok)\s+(.*)$/.exec(l))
+		.filter((m) => m !== null)
+		.map((m) => /** @type {RegExpExecArray} */ (m)[1].trim());
+}
+
+/** did the suite reach helpers.finish (its own verdict line) rather than crash @param {string} log */
+function finished(log) {
+	return /^(ALL PASS|\d+ FAILURES)\s*$/m.test(log) && !/^SCRIPT FAILED/m.test(log);
+}
+
+/**
+ * Is this red non-blocking? @param {Quarantine} q @param {string} suite @param {string} log
+ * @param {{timedOut?: boolean}} [opts] @returns {Verdict}
+ */
+function classify(q, suite, log, opts = {}) {
+	const mine = (q.quarantine ?? []).filter((e) => e.suite === suite);
+	const whole = mine.find((e) => !e.check);
+	const failed = failedChecks(log);
+	if (whole) return { quarantined: true, whole: true, failed, unmatched: [], entries: [whole] };
+	const used = new Set();
+	const unmatched = failed.filter((label) => {
+		const hit = mine.find((e) => e.check && label.includes(e.check));
+		if (hit) used.add(hit);
+		return !hit;
+	});
+	const covered = !opts.timedOut && finished(log) && failed.length > 0 && unmatched.length === 0;
+	return { quarantined: covered, whole: false, failed, unmatched, entries: [...used] };
+}
+
+/**
+ * What to act on: past review dates, entries that saw their suite (or their check) green, and entries
+ * for suites the battery no longer has. @param {Quarantine} q
+ * @param {{name: string, status: string, log?: string}[]} results @param {string[]} [known] suite names
+ * @param {string} [today] YYYY-MM-DD
+ */
+function warnings(q, results = [], known, today = new Date().toISOString().slice(0, 10)) {
+	/** @type {string[]} */
+	const out = [];
+	const byName = new Map(results.map((r) => [r.name, r]));
+	for (const e of q.quarantine ?? []) {
+		const tag = `${e.suite}${e.check ? ' "' + e.check + '"' : ''}`;
+		if (e.review < today) out.push(`quarantine ${tag}: review date ${e.review} has passed (owner ${e.owner}) — fix it, delete the check, or re-date the entry`);
+		const r = byName.get(e.suite);
+		if (r && r.status === 'pass') out.push(`quarantine ${tag}: the suite ran green — remove the entry once it holds`);
+		else if (r && e.check && r.log != null && !failedChecks(r.log).some((l) => l.includes(/** @type {string} */ (e.check)))) out.push(`quarantine ${tag}: that check did not fail this run`);
+		if (known && !known.includes(e.suite)) out.push(`quarantine ${tag}: no such suite in the battery — stale entry`);
+	}
+	return out;
+}
+
+/**
+ * Split an integrator battery.sh summary (`<suite> rc=<n> pass~ fail~ <s>s :: <last line>`) into the
+ * reds that gate and the ones the quarantine covers. Reads <logdir>/<suite>.log for the check names.
+ * @param {string} summaryFile @param {string} [logDir]
+ */
+function triage(summaryFile, logDir = path.dirname(summaryFile)) {
+	const q = load();
+	/** @type {{name: string, rc: string, v: Verdict}[]} */
+	const blocking = [];
+	/** @type {{name: string, rc: string, v: Verdict}[]} */
+	const quarantined = [];
+	/** @type {{name: string, status: string, log?: string}[]} */
+	const results = [];
+	for (const line of fs.readFileSync(summaryFile, 'utf8').split('\n')) {
+		const m = /^(\S+) rc=(\S+) /.exec(line);
+		if (!m || m[1].startsWith('MOD:')) continue;
+		const [, name, rc] = m;
+		const logFile = path.join(logDir, name + '.log');
+		const log = fs.existsSync(logFile) ? fs.readFileSync(logFile, 'utf8') : '';
+		results.push({ name, status: rc === '0' ? 'pass' : 'fail', log });
+		if (rc === '0') continue;
+		const v = classify(q, name, log, { timedOut: rc === '124' });
+		(v.quarantined ? quarantined : blocking).push({ name, rc, v });
+	}
+	return { blocking, quarantined, warnings: warnings(q, results) };
+}
+
+if (require.main === module) {
+	const [cmd, ...argv] = process.argv.slice(2);
+	const q = load();
+	const errors = validate(q);
+	if (cmd === 'check' || !cmd) {
+		for (const e of errors) console.error('quarantine.json: ' + e);
+		for (const w of warnings(q)) console.log('warning: ' + w);
+		console.log(errors.length ? `${errors.length} errors` : `quarantine.json: ${q.quarantine.length} entries OK`);
+		process.exit(errors.length ? 1 : 0);
+	} else if (cmd === 'list') {
+		for (const e of [...q.quarantine].sort((a, b) => (a.review < b.review ? -1 : 1))) console.log(`${e.review}  ${e.suite}${e.check ? ' :: ' + e.check : ' (whole suite)'}  — ${e.owner}`);
+	} else if (cmd === 'triage' && argv[0]) {
+		if (errors.length) {
+			for (const e of errors) console.error('quarantine.json: ' + e);
+			process.exit(2);
+		}
+		const t = triage(argv[0], argv[1]);
+		for (const b of t.blocking) console.log(`RED  ${b.name} rc=${b.rc}${b.v.unmatched.length ? ' :: ' + b.v.unmatched.slice(0, 3).join(' | ') : ''}`);
+		for (const b of t.quarantined) console.log(`QUAR ${b.name} :: ${b.v.whole ? 'whole suite' : b.v.failed.join(' | ')}`);
+		for (const w of t.warnings) console.log('warning: ' + w);
+		console.log(`${t.blocking.length} blocking red, ${t.quarantined.length} quarantined`);
+		process.exit(t.blocking.length ? 1 : 0);
+	} else {
+		console.error('usage: quarantine.cjs check | list | triage <summary.txt> [<logdir>]');
+		process.exit(2);
+	}
+}
+
+module.exports = { QUARANTINE, load, validate, failedChecks, finished, classify, warnings, triage };
diff --git a/src/components/Scene.svelte b/src/components/Scene.svelte
index 8ae36b01a..46af1bbd0 100644
--- a/src/components/Scene.svelte
+++ b/src/components/Scene.svelte
@@ -395,7 +395,7 @@
 			// so its local position put every walking player 0.9 m into the floor on every peer.
 			camera.current.updateWorldMatrix(true, false);
 			camera.current.matrixWorld.decompose(camContentPos, camContentQuat, camFeetPoint);
-			const feetWorld = localFeet();
+			const feetWorld = localFeet(delta * 1000);
 			const camExtras: Record<string, number> = {};
 			if (feetWorld !== null) {
 				camFeetPoint.set(camContentPos.x, feetWorld, camContentPos.z);
@@ -1422,6 +1422,13 @@
 		});
 
 		const onContextMenu = (event) => {
+			// test-health-1: heard on threlte's WRAPPER (`dom`), not the canvas. OrbitControls listens
+			// there and captures the pointer on every press, right button included, so where
+			// `contextmenu` fires on mousedown (Linux; Chromium headless) it is dispatched to the capture
+			// element and a canvas listener never heard it — a real right-click on the viewport opened
+			// nothing (fresh page: 0 menu rows; play-reentry). Canvas events still bubble here; anything
+			// else inside the wrapper keeps its own menu.
+			if (event.target !== element && event.target !== dom) return;
 			event.preventDefault(); // the browser menu never belongs on the canvas
 			const down = rightDown;
 			rightDown = null;
@@ -1431,7 +1438,7 @@
 			if (moved > 5 || Date.now() - down[2] > 400) return;
 			openViewportMenuAt(event.clientX, event.clientY);
 		};
-		element.addEventListener('contextmenu', onContextMenu);
+		dom.addEventListener('contextmenu', onContextMenu);
 
 		// touch long-press = right-click (touch has no contextmenu). A stationary
 		// ~500ms hold opens the same menu at the touch point.
@@ -1666,7 +1673,7 @@
 			stopClap(); // 31
 			stopVrGameInput(); // 30b
 			element.removeEventListener('pointerdown', onPointerDown);
-			element.removeEventListener('contextmenu', onContextMenu);
+			dom.removeEventListener('contextmenu', onContextMenu);
 			element.removeEventListener('webglcontextlost', onContextLost);
 			element.removeEventListener('webglcontextrestored', onContextRestored);
 			window.removeEventListener('pointerup', onPointerUp);
diff --git a/src/lib/avatars/avatarState.js b/src/lib/avatars/avatarState.js
index 256d51dd2..c35cf182e 100644
--- a/src/lib/avatars/avatarState.js
+++ b/src/lib/avatars/avatarState.js
@@ -63,11 +63,14 @@ export function setLocalFeet(y) {
 	feetY = Number.isFinite(y) ? /** @type {number} */ (y) : null;
 	feetAt = typeof performance !== 'undefined' ? performance.now() : 0;
 }
-/** @returns {number | null} */
-export function localFeet() {
+/** @param {number} [frameMs] the reader's frame time: the writer runs once per frame and the reader
+ * sees the previous frame's write, so below ~4 fps a fixed 250 ms called every reading stale and the
+ * body fell under the head on every peer (avatar-feet 1.7; any >250 ms hitch did it too)
+ * @returns {number | null} */
+export function localFeet(frameMs = 0) {
 	if (feetY === null) return null;
 	const now = typeof performance !== 'undefined' ? performance.now() : 0;
-	return now - feetAt > FEET_STALE_MS ? null : feetY;
+	return now - feetAt > Math.max(FEET_STALE_MS, 2 * frameMs) ? null : feetY;
 }
 
 // 37 R22: THIS player is "knocked off" — no input for `knockedAfterSeconds`. The camera broadcast
diff --git a/src/lib/flowRuntime.js b/src/lib/flowRuntime.js
index 619962fa9..411e7ba72 100644
--- a/src/lib/flowRuntime.js
+++ b/src/lib/flowRuntime.js
@@ -129,6 +129,11 @@ const restFired = new Map();
 /** B6: rising-edge map for the physics ACTION nodes (a pulse is high ~0.3 s, so
  * an action must run once per pulse, not once per frame) @type {Map<string, boolean>} */
 const physicsActionEdge = new Map();
+/** test-health-1: the trigger STAMP each physics action last saw. A pulse is high for 0.3 s, so a
+ * frame longer than that (below ~3.3 fps: two pages on software GL, a slow phone) can step over the
+ * whole pulse and the rising VALUE never shows — the trigger stamp still changed, and that is the
+ * event. @type {Map<string, number|null>} */
+const physicsActionStamp = new Map();
 
 // --- 21-E6 follow-up: THE STALE-STAMP GUARD, shared by every trigger-edge family ----
 //
@@ -665,8 +670,14 @@ function updatePhysicsActions(pairs, ctx, time) {
 		if (!target) continue;
 		const was = physicsActionEdge.get(node.id) ?? false;
 		physicsActionEdge.set(node.id, high);
+		const stamp = triggerStampFor(node.id, ctx);
+		const lastStamp = physicsActionStamp.get(node.id);
+		physicsActionStamp.set(node.id, stamp);
+		// a NEW stamp is a rising edge even when the pulse it made fell between two ticks; first sight
+		// (no last stamp) is not — that is a pulse from before this node, and staleTrigger has it
+		const freshStamp = typeof stamp === 'number' && lastStamp !== undefined && stamp !== lastStamp;
 		const continuous = node.type === 'setvelocity' && (data.mode ?? 'once') === 'continuous';
-		if (!continuous && (!high || was)) continue;
+		if (!continuous && !((high && !was) || freshStamp)) continue;
 		if (continuous && !high) continue;
 		// ...and the pulse that made us high may PREDATE this node. This family reads a
 		// rising VALUE rather than a stamp, so its exposure was only the ~0.3s a pulse
@@ -675,7 +686,7 @@ function updatePhysicsActions(pairs, ctx, time) {
 		// behind the pulse is what answers it. A pulse with NO stamp (a Toggle wired into
 		// `trigger`) is never refused, and a continuous Set Velocity keeps running,
 		// because after its first tick every live stamp is newer than the cutoff.
-		if (staleTrigger(node, triggerStampFor(node.id, ctx))) continue;
+		if (staleTrigger(node, stamp)) continue;
 		// a physics action in a scene that is not simulating is a no-op, and used to
 		// be a SILENT one — the graph is right, the key fires, nothing moves
 		// initiator-gated by design, so a NON-initiator doing nothing here is correct
@@ -712,6 +723,7 @@ function updatePhysicsActions(pairs, ctx, time) {
 		}
 	}
 	for (const id of [...physicsActionEdge.keys()]) if (!seen.has(id)) physicsActionEdge.delete(id);
+	for (const id of [...physicsActionStamp.keys()]) if (!seen.has(id)) physicsActionStamp.delete(id);
 }
 
 let lastNoSimWarn = 0;
diff --git a/src/lib/lockControl.js b/src/lib/lockControl.js
index 7512e2d61..c1daf70d8 100644
--- a/src/lib/lockControl.js
+++ b/src/lib/lockControl.js
@@ -101,7 +101,10 @@ export function startLockSweep() {
 			locks.filter((l) => {
 				if (l[0] === peer.peer.id) return true;
 				const conn = peer.connections[l[0]];
-				return !!(conn && conn.open);
+				// test-health-1: mid-blip the holder's conn is down but the reconnect window still runs —
+				// their lock survives until finalizeDisconnect decides (the rule checkLocks keeps, B5).
+				// Without it a sweep landing inside a drop released a live peer's locks (net-drop HARD).
+				return !!(conn && conn.open) || !!peer.reconnecting?.has(l[0]);
 			})
 		);
 	}, 60000);
diff --git a/src/lib/peerHandler.svelte.js b/src/lib/peerHandler.svelte.js
index 73b5fa4de..16262f17d 100644
--- a/src/lib/peerHandler.svelte.js
+++ b/src/lib/peerHandler.svelte.js
@@ -179,6 +179,11 @@ export function createPeer() {
 // remote had already adopted as its send channel. Killing young conns is how
 // mesh formation shredded itself above ~5 peers.
 const DIAL_GRACE_MS = 10000;
+/** test-health-1: what the reconnect window's FINAL verdict gives a dial still negotiating (either
+ * direction). Longer than DIAL_GRACE_MS on purpose: a redial after a 5 s drop starts late (when the
+ * signaling link returns) and measured ~12 s to open on a loaded box — the 10 s grace tore it down a
+ * second before it opened (net-drop HARD). A teardown is the expensive mistake here. */
+const VERDICT_GRACE_MS = 20000;
 // 27-F: the SIGNALING schedule — 800ms doubling to a 8s ceiling, forever, +/-25% so a
 // room full of tabs does not return in lockstep. Separate from the per-peer conn
 // backoff below, which is bounded on purpose (a peer really can be gone).
@@ -282,6 +287,11 @@ export class PeerConnection {
 		 * toast) waits until the backoff exhausts; checkLocks keeps the peer's
 		 * locks and roster entry alive for the window (B5, 172 deferred item 1) */
 		this.reconnecting = new Map();
+		// test-health-1: inbound dials from a peer in the reconnect window, while they negotiate
+		// (the higher id only ever heals through one) — scheduleReconnect's final verdict waits
+		// for them as it waits for its own dial
+		/** @type {Map<string, any>} */
+		this.inboundDials = new Map();
 		/** @type {Set<string>} peers that ANNOUNCED they were leaving (the
 		 * `disconnected` self-message) — their close is expected, don't redial */
 		this.gracefulLeft = new Set();
@@ -393,7 +403,20 @@ export class PeerConnection {
 			cancelTimers();
 			const old = this.peer;
 			if (old) retired.add(old);
-			try { old.destroy(); } catch (e) { /* already gone */ }
+			// test-health-1: rebuilding the SIGNALING link must not cut the PEER links. destroy() closes
+			// every DataConnection the old Peer owns (peerjs _cleanup), and an open DataConnection needs
+			// no server — so a reconnect that stalled (watchOpen, 10 s after a wifi drop) used to end
+			// every live conn with it and push them all into the reconnect window. disconnect() drops the
+			// server socket only ("does not close any active connections"); the old Peer is retired, so
+			// none of its handlers act again. Nothing open to keep -> destroy, as before.
+			const keepLinks = !!old && !old.destroyed && Object.values(this.connections).some((/** @type {any} */ c) => c?.open);
+			try { if (keepLinks) old.disconnect(); else old.destroy(); } catch (e) { /* already gone */ }
+			// …but only the OPEN links survive: a conn still negotiating needed the old socket for its
+			// answer and candidates and can never finish now — close it exactly as destroy() did, so its
+			// close runs the usual paths (reconnect window / mesh restore) instead of wedging
+			if (keepLinks)
+				for (const c of Object.values(this.connections))
+					if (c && !(/** @type {any} */ (c).open)) try { /** @type {any} */ (c).close(); } catch (e) { /* never opened */ }
 			createPeerForMode(!!forcePublic);
 			attachVoiceToPeer(this); // rebind the incoming-call handler to the new peer
 			wire();
@@ -505,6 +528,22 @@ export class PeerConnection {
 			this.signalingNotified = false;
 			peers.update((value) => value); // the dot reads peer.open: tick the store
 			this.reconnectAttempts = 0; // a fresh/re-established server link resets the backoff
+			// test-health-1: the window's dials while the server was unreachable never left
+			// (`peer.connect` is undefined with the link down) — redial NOW, not on the next
+			// backoff tick, which can be the verdict-only one (a 5 s wifi drop: no dial until 7.5 s)
+			// A dial still un-open at this moment was made while the link was down — its offer never
+			// reached the server, yet it holds the slot until its DIAL_GRACE expires, and after a 5 s
+			// drop that is past the window's last dial (net-drop HARD: the session tore down with one
+			// such dial "negotiating" for 15 s). Replace it (delete first, so onConnClose ignores the
+			// close of a conn we no longer hold).
+			for (const peerId of this.reconnecting.keys()) {
+				const stale = this.connections[peerId];
+				if (stale && !stale.open) {
+					delete this.connections[peerId];
+					try { stale.close(); } catch (e) { /* never opened */ }
+				}
+				this.reconnectDial(peerId);
+			}
 			if (this.updateIdFn) this.updateIdFn(id);
 			if (!window.location.hash.slice(1)) return;
 			let connect = window.location.hash.slice(1).toLocaleLowerCase()
@@ -769,6 +808,12 @@ export class PeerConnection {
 				conn.close();
 			}
 
+			// test-health-1: an inbound redial from a peer we are waiting for is a heal in progress
+			if (this.reconnecting.has(conn.peer)) {
+				/** @type {any} */ (conn).__dialedAt = Date.now();
+				this.inboundDials.set(conn.peer, conn);
+			}
+
 			// ADOPT an open inbound conn as our send channel when our outgoing one
 			// is dead (P-A find): the host closes the joiner's original conn before
 			// approving, the close is often never signaled, and the fresh reopen can
@@ -789,8 +834,9 @@ export class PeerConnection {
 				// relationship, or a reconnect resyncing what the blip dropped. A
 				// mesh-fill adoption asking a JOINER for its objects was pure
 				// duplication — and could pop a bogus share-or-stash prompt (B5).
-				const wantState = this.wantsStateFrom.has(conn.peer) || this.reconnecting.has(conn.peer);
-				this.sendHandshake(conn, conn.peer, wantState, this.peer.id);
+				const healing = this.reconnecting.has(conn.peer);
+				const wantState = this.wantsStateFrom.has(conn.peer) || healing;
+				this.sendHandshake(conn, conn.peer, wantState, this.peer.id, { heal: healing });
 			});
 
 			this.wireData(conn);
@@ -1543,8 +1589,9 @@ export class PeerConnection {
 
 	// Send the initial handshake (locks, known hosts, whitelist, object/node sync requests).
 	// Must only be called once the connection is open — messages sent earlier are dropped by peerjs.
-	/** @param {any} conn @param {string} peerId @param {boolean} getobjects @param {string} id */
-	sendHandshake(conn, peerId, getobjects, id) {
+	/** @param {any} conn @param {string} peerId @param {boolean} getobjects @param {string} id
+	 * @param {{heal?: boolean}} [opts] heal: this conn REPLACES one that dropped (the reconnect window) */
+	sendHandshake(conn, peerId, getobjects, id, opts = {}) {
 		// 25-F: an approval dial-back SAYS it is one, ahead of everything else (the roadmap's
 		// "first message"). The metadata already carried it; this is the same answer for a
 		// peer that reads messages rather than metadata, and it is idempotent on a joiner
@@ -1616,7 +1663,10 @@ export class PeerConnection {
 		// DECISION: there is no decision here, and the ask comes back the moment we share or
 		// rejoin (both end in a full-state re-sync of their own).
 		const secret = hostsPrivate;
-		const holdContent = secret || (getobjects && connectDecisionApplies(get(sessionHost) === peerId, myScene()?.scene ?? ''));
+		// test-health-1: the connect decision is a FIRST-CONTACT question; a healed conn is the same
+		// session coming back, so it never holds (it deferred our state for a decision nobody asked:
+		// net-drop HARD healed, open both ways, and no edit crossed)
+		const holdContent = secret || (getobjects && !opts.heal && connectDecisionApplies(get(sessionHost) === peerId, myScene()?.scene ?? ''));
 		if (holdContent && !secret) noteHandshakeDeferred(peerId);
 		if (!holdContent) {
 			conn.send(environmentState())
@@ -1633,7 +1683,10 @@ export class PeerConnection {
 		conn.send(handModelState())
 		conn.send(envPresetsState())
 		conn.send(materialPresetsState())
-		if (getobjects && !holdContent) this.requestFullState(conn)
+		// test-health-1: a HEALED conn re-syncs as `arriving` — what each side holds is the same room's
+		// scene, so it is not two worlds merging: without the flag the far side asked share-or-stash
+		// and its gate DROPPED everything we sent (net-reconnect / net-drop: open both ways, edits lost)
+		if (getobjects && !holdContent) this.requestFullState(conn, opts.heal ? { arriving: true } : {})
 		// singleton PUSH, like environmentState/scenePhysicsState above
 		if (!holdContent) conn.send(gameStatePayload())
 		// 34 R2: the kit document, the same singleton push (its events are NOT sent: history fires nothing)
@@ -1860,6 +1913,24 @@ export class PeerConnection {
 	scheduleReconnect(peerId, attempt) {
 		const delay = backoffDelay(attempt, { base: 500, max: 5 });
 		if (delay === null) {
+			// test-health-1: the verdict waits out a dial that is still negotiating, either way
+			// round (6-12 s measured on a loaded box, VERDICT_GRACE_MS). After a 5 s drop the
+			// first dial that can leave goes out at ~5-7.5 s, so tearing down at 15.5 s killed
+			// heals in flight: "disconnected" toasts and a dead session (net-drop HARD).
+			const inFlight = [this.connections[peerId], this.inboundDials.get(peerId)]
+				.filter((c) => c && !c.open)
+				.map((c) => VERDICT_GRACE_MS - (Date.now() - (c.__dialedAt ?? 0)))
+				.filter((left) => left > 0);
+			if (inFlight.length) {
+				this.reconnecting.set(peerId, attempt); // still in the window, under a fresh token
+				setTimeout(() => {
+					if (this.reconnecting.get(peerId) !== attempt) return; // healed, superseded or left
+					if (this.connections[peerId]?.open) { this.reconnecting.delete(peerId); this.inboundDials.delete(peerId); return; }
+					this.reconnecting.delete(peerId);
+					this.finalizeDisconnect(peerId, true);
+				}, Math.max(...inFlight));
+				return;
+			}
 			this.reconnecting.delete(peerId);
 			this.finalizeDisconnect(peerId, true);
 			return;
@@ -1869,7 +1940,7 @@ export class PeerConnection {
 			if (this.reconnecting.get(peerId) !== attempt) return; // superseded or cancelled
 			if (!this.openedPeers.has(peerId)) { this.reconnecting.delete(peerId); return; } // torn down elsewhere
 			const existing = this.connections[peerId];
-			if (existing?.open) { this.reconnecting.delete(peerId); return; } // healed (redial or adopted inbound)
+			if (existing?.open) { this.reconnecting.delete(peerId); this.inboundDials.delete(peerId); return; } // healed (redial or adopted inbound)
 			// a dial un-open past the dial grace is genuinely wedged — clear it.
 			// Anything younger is just negotiating (measured 6-9s on a loaded
 			// headless box; closing it early poisons the NEXT negotiation too —
@@ -1881,25 +1952,31 @@ export class PeerConnection {
 			// dial (lower id only), unless this is the verdict-only final check —
 			// a dial started now would be torn down before it could ever open
 			const lastCheck = backoffDelay(attempt + 1, { base: 500, max: 5 }) === null;
-			if (!this.connections[peerId] && !lastCheck && this.peer.id < peerId) {
-				const conn = this.peer.connect(peerId, dialOptions());
-				if (conn) {
-					/** @type {any} */ (conn).__dialedAt = Date.now();
-					this.connections[peerId] = conn;
-					conn.on('close', () => this.onConnClose(peerId, conn));
-					conn.on('open', () => {
-						log('info', 'net', 'reconnected', { peer: peerId });
-						this.reconnecting.delete(peerId);
-						peers.update((value) => value);
-						this.sendHandshake(conn, peerId, true, this.peer.id);
-					});
-					this.wireData(conn);
-				}
-			}
+			if (!lastCheck) this.reconnectDial(peerId);
 			this.scheduleReconnect(peerId, attempt + 1);
 		}, delay);
 	}
 
+	/** One reconnect-window dial: the lower id only, and never over a dial already in flight.
+	 * Called from the window's timers and when the signaling link comes back.
+	 * @param {string} peerId */
+	reconnectDial(peerId) {
+		if (this.connections[peerId] || !(this.peer.id < peerId)) return;
+		const conn = this.peer.connect(peerId, dialOptions());
+		if (!conn) return; // the signaling link is down: the next tick (or its return) redials
+		/** @type {any} */ (conn).__dialedAt = Date.now();
+		this.connections[peerId] = conn;
+		conn.on('close', () => this.onConnClose(peerId, conn));
+		conn.on('open', () => {
+			log('info', 'net', 'reconnected', { peer: peerId });
+			this.reconnecting.delete(peerId);
+			this.inboundDials.delete(peerId);
+			peers.update((value) => value);
+			this.sendHandshake(conn, peerId, true, this.peer.id, { heal: true });
+		});
+		this.wireData(conn);
+	}
+
 	// The peer is really gone: full per-peer teardown (self-heal — a relayed
 	// 'disconnected' never reaches the last peer in a 2-peer session, so voice
 	// nodes / VR hands / flow cursors / env presets used to leak, 172). With
@@ -1909,6 +1986,7 @@ export class PeerConnection {
 	/** @param {string} peerId @param {boolean} relay */
 	finalizeDisconnect(peerId, relay) {
 		this.reconnecting.delete(peerId);
+		this.inboundDials.delete(peerId);
 		const conn = this.connections[peerId];
 		if (conn) {
 			delete this.connections[peerId];
@@ -1947,6 +2025,7 @@ export class PeerConnection {
 		this.broadcast({ type: 'disconnected', peerId: this.peer.id });
 		dropPeerUnderlays(null); // 60 Q5: every peer's shared reference images go with the session
 		this.reconnecting.clear(); // pending retry timers see a cleared map and no-op
+		this.inboundDials.clear();
 		this.gracefulLeft.clear();
 		this.wantsStateFrom.clear();
 		// 60 Q2: every fast channel, sequence and owed keyframe goes with the session
diff --git a/src/lib/sessions.js b/src/lib/sessions.js
index c7d2d64cf..64292377b 100644
--- a/src/lib/sessions.js
+++ b/src/lib/sessions.js
@@ -162,12 +162,14 @@ export function viewportThumbnail(maxW = 256) {
 
 /** The saved entry's picture. @param {any} group @returns {string|null} */
 function renderSceneThumbnail(group) {
+	/** @type {THREE.WebGLRenderer | null} */
+	let renderer = null;
 	try {
 		if (!group || group.children.length === 0) return null;
 		// the live viewport first — see viewportThumbnail for why
 		const live = viewportThumbnail();
 		if (live) return live;
-		const renderer = new THREE.WebGLRenderer({ antialias: true, alpha: true });
+		renderer = new THREE.WebGLRenderer({ antialias: true, alpha: true });
 		renderer.setSize(256, 160);
 		const scene = new THREE.Scene();
 		scene.background = new THREE.Color('#232a33');
@@ -182,13 +184,15 @@ function renderSceneThumbnail(group) {
 		camera.position.copy(center).add(new THREE.Vector3(size * 0.65, size * 0.5, size * 0.85));
 		camera.lookAt(center);
 		renderer.render(scene, camera);
-		const url = renderer.domElement.toDataURL('image/webp', 0.7);
-		renderer.dispose();
-		renderer.forceContextLoss?.();
-		return url;
+		return renderer.domElement.toDataURL('image/webp', 0.7);
 	} catch (error) {
 		console.log('session thumbnail failed', error);
 		return null;
+	} finally {
+		// every exit, the empty-box early return and a throw included: a renderer that is not
+		// released holds its WebGL context until GC, and Chromium caps live contexts at 16
+		renderer?.dispose();
+		renderer?.forceContextLoss?.();
 	}
 }
 
diff --git a/src/lib/shaderGraph.js b/src/lib/shaderGraph.js
index 7486223bb..945f47673 100644
--- a/src/lib/shaderGraph.js
+++ b/src/lib/shaderGraph.js
@@ -206,6 +206,19 @@ export function registerShaderTargets(fn) {
 	};
 }
 
+/** keys whose target object has not arrived -> retries made @type {Map<string, number>} */
+const missingTries = new Map();
+/** 0.25 s doubling to 4 s, ~20 s in all; then the objectsGroup reconcile alone @param {string} key */
+function retryMissingTarget(key) {
+	const tries = (missingTries.get(key) ?? 0) + 1;
+	if (tries > 8) {
+		missingTries.delete(key);
+		return;
+	}
+	missingTries.set(key, tries);
+	scheduleCompile(key, Math.min(4000, 250 * 2 ** (tries - 1)));
+}
+
 /**
  * Debounced: an editor drag writes many times a second, and a compile per keystroke is
  * wasted work even at inject's 0.4 ms.
@@ -274,6 +287,13 @@ export async function compileAndApply(key) {
 		return { ok: false, errors: result.errors };
 	}
 	const targets = targetsFor(key);
+	// test-health-1: a graph for an OBJECT that has not arrived yet (a late joiner's graph reply is
+	// far smaller than the GLTF that carries the object) compiles nothing — and the reconcile below
+	// waits on an objectsGroup poke the object's arrival does not always make (shader-sync: the
+	// joiner held both graph and cube, never compiled; a manual reconcile compiled it at once).
+	// Retry on its own, briefly; the reconcile still covers anything later.
+	if (!targets.length && key !== SCENE_GRAPH_KEY) retryMissingTarget(key);
+	else missingTries.delete(key);
 	/** @type {string[]} */
 	const errors = [];
 	for (const object of targets) {
diff --git a/src/modules/button/module.js b/src/modules/button/module.js
index a45f6cced..e500b6b7f 100644
--- a/src/modules/button/module.js
+++ b/src/modules/button/module.js
@@ -52,7 +52,7 @@ export default {
 		);
 
 		// clicking the chosen button object presses the node instead of selecting
-		api.registerClickHandler((object) => {
+		api.registerClickHandler((/** @type {import('three').Object3D} */ object) => {
 			const group = api.objectsGroup();
 			if (!group) return false;
 			let top = object;
@@ -67,11 +67,11 @@ export default {
 		});
 
 		// door effect: slide the connected object up while pressed
-		api.registerEffect('buttontrigger', (object, base, data, time) => {
+		api.registerEffect('buttontrigger', /** @param {import('three').Object3D} object @param {{pos: number[], rot: number[], scale: number[]}} base @param {Record<string, any>} data @param {number} time */ (object, base, data, time) => {
 			const height = data.height ?? 2;
 			const duration = Math.max(Math.abs(height) / 2, 0.15); // ~2 m/s
 			const at = data.at ?? 0;
-			const clamp01 = (value) => Math.min(Math.max(value, 0), 1);
+			const clamp01 = (/** @type {number} */ value) => Math.min(Math.max(value, 0), 1);
 			let lift;
 			if (data.pressed) {
 				lift = clamp01((time - at) / duration);
diff --git a/src/modules/hello/module.js b/src/modules/hello/module.js
index 5ae42ef3f..99cb9663d 100644
--- a/src/modules/hello/module.js
+++ b/src/modules/hello/module.js
@@ -24,7 +24,7 @@ export default {
 			]
 		});
 
-		api.registerEffect('wave', (object, base, data, time) => {
+		api.registerEffect('wave', /** @param {import('three').Object3D} object @param {{pos: number[], rot: number[], scale: number[]}} base @param {Record<string, any>} data @param {number} time */ (object, base, data, time) => {
 			const amplitude = data.amplitude ?? 0.4;
 			const speed = data.speed ?? 2;
 			object.rotation.z = base.rot[2] + Math.sin(time * speed) * amplitude;
diff --git a/tests/e2e/README.md b/tests/e2e/README.md
index 5b326e66d..afb154aa3 100644
--- a/tests/e2e/README.md
+++ b/tests/e2e/README.md
@@ -80,3 +80,19 @@ light and custom (`fixtures/lock/lock-custom.theme.json`) themes, named
 
 All lock suites launch on the GPU backend (`lockHelpers.launch`): on SwiftShader the 3D view
 behind the panels starves the page (a CDP round trip measured 271 ms vs 2 ms).
+
+## Quarantine (test-health-1)
+
+`tests/e2e/quarantine.json` lists the checks that run but do not gate: a known flake or a known red,
+each with the suite, optionally ONE check (a substring of its `FAIL <label>` line), the reason, an
+owner, `since` and a `review` date — the `allow` list of `perf/budgets.json`, for e2e. It replaced
+battery.json's suite-wide `optional` map.
+
+- The CI battery (`scripts/ci/battery.cjs`) reports a red that is red twice and whose EVERY failed check
+  is quarantined as `quarantined`, in its own tier; it does not fail the run. A crash or a timeout is
+  never covered by a check entry (only by a whole-suite entry, `check` absent).
+- An integrator's `battery.sh` summary: `node scripts/ci/quarantine.cjs triage <summary.txt> [<logdir>]`
+  prints `RED` (gates) / `QUAR` (does not) per suite and exits 1 on a blocking red.
+- `node scripts/ci/quarantine.cjs check` validates the file; `list` prints it by review date. A past
+  review date or an entry whose suite ran green is a WARNING — fix the check, delete it with a reason,
+  or re-date the entry. Remove an entry in the PR that fixes it.
diff --git a/tests/e2e/animation-sync.test.cjs b/tests/e2e/animation-sync.test.cjs
index 6f99b8999..78d04c9a1 100644
--- a/tests/e2e/animation-sync.test.cjs
+++ b/tests/e2e/animation-sync.test.cjs
@@ -245,7 +245,19 @@ h.run(async () => {
 		ap.updateAnim(obj.uuid, { duration: 1, loop: 'once' });
 		return obj.uuid;
 	});
-	await A.page.waitForTimeout(1500);
+	// the door has to REACH the third page first (a fixed 1.5 s read it at x=0.03 under load) — wait for
+	// it at its real place, bounded; the check below still says where it was if it never came
+	await h.eventually(
+		() => C.page.evaluate((id) => {
+			let g;
+			window.__stores.objectsGroup.subscribe((x) => (g = x))();
+			const obj = g?.getObjectByProperty('uuid', id);
+			return obj ? obj.getWorldPosition(new window.__stores.THREE.Vector3()).x : null;
+		}, doorUuid),
+		(x) => x !== null && Math.abs(x - 3) < 0.01,
+		'(premise) the door arrives on the joiner',
+		15000
+	);
 
 	// where C thinks the hinge is BEFORE the door opens — the invariant to hold
 	const hingeClosed = await C.page.evaluate((id) => {
@@ -266,6 +278,16 @@ h.run(async () => {
 	);
 	await A.page.evaluate((id) => window.__stores.animationPreview.play(id), doorUuid);
 	await A.page.waitForTimeout(1600); // a 'once' clip: both peers end at 90deg
+	// test-health-1: only a FRAME poses the door and ends the clip (tickAnimationPreview runs from
+	// Scene's useTask), and C is a third software-GL page — 1600 ms was not always one of C's
+	// frames (0.0deg, still playing, while two reads later showed it at 90). Poll, bounded: a C
+	// that never got or never evaluates `animplay` still reads wrong at the end.
+	const ended = (/** @type {any} */ r) => r && r.rotY !== null && Math.abs(r.rotY - Math.PI / 2) < 0.02 && !r.playing;
+	for (let t = Date.now(); Date.now() - t < 15000; ) {
+		const [a, c] = await Promise.all([readAnim(A.page, doorUuid), readAnim(C.page, doorUuid)]);
+		if (ended(a) && ended(c)) break;
+		await A.page.waitForTimeout(250);
+	}
 
 	const [doorA, doorC] = await Promise.all([readAnim(A.page, doorUuid), readAnim(C.page, doorUuid)]);
 	h.check(
diff --git a/tests/e2e/aquarium-reef.test.cjs b/tests/e2e/aquarium-reef.test.cjs
index 1bf95eef2..9fd196a82 100644
--- a/tests/e2e/aquarium-reef.test.cjs
+++ b/tests/e2e/aquarium-reef.test.cjs
@@ -100,14 +100,19 @@ h.run(async () => {
 	// midpoint sits on the centre and the closest they get is the minor diameter, 1.0 m
 	const mid = tang.map((t) => Math.hypot((t.a[0] + t.b[0]) / 2 - 0.1, (t.a[2] + t.b[2]) / 2 - 0.05));
 	h.check(Math.max(...mid) < 0.15 && Math.min(...apart) > 0.9, '1.2 the two tangs ride HALF A LAP apart (offset 0.5): midpoint within ' + Math.max(...mid).toFixed(2) + ' m of the loop centre, ' + Math.min(...apart).toFixed(2) + ' m at the closest');
+	// over the samples where the fish MOVED: a 250 ms interval with no rendered frame in it (software
+	// GL, ~4 fps) has no direction and used to score 0 — two of eleven gave exactly 0.82 (1.7 skips them too)
 	let along = 0;
+	let an = 0;
 	for (let i = 1; i < tang.length; i++) {
 		const d = [tang[i].a[0] - tang[i - 1].a[0], tang[i].a[1] - tang[i - 1].a[1], tang[i].a[2] - tang[i - 1].a[2]];
-		const l = Math.hypot(...d) || 1;
+		const l = Math.hypot(...d);
+		if (l < 0.01) continue; // no frame landed between these two samples
 		const n = tang[i].nose;
 		along += (d[0] * n[0] + d[1] * n[1] + d[2] * n[2]) / l;
+		an++;
 	}
-	h.check(along / (tang.length - 1) > 0.85, '1.3 its nose points along the travel (mean cos ' + (along / (tang.length - 1)).toFixed(2) + ')');
+	h.check(an >= 6 && along / an > 0.85, '1.3 its nose points along the travel (mean cos ' + (along / Math.max(1, an)).toFixed(2) + ' over ' + an + ' moving samples)');
 	const maxRoll = Math.max(...tang.map((t) => Math.abs(t.up[0] * t.nose[2] - t.up[2] * t.nose[0]) + Math.abs(Math.hypot(t.up[0], t.up[2]))));
 	h.check(maxRoll > 0.05, '1.4 it BANKS in the bends (top tilts off vertical by up to ' + maxRoll.toFixed(2) + ')');
 	const box = await page.evaluate(() => window.__aq.waterBox());
@@ -224,19 +229,23 @@ h.run(async () => {
 	await B.page.route(/aquarium-kit\/.*\.glb/, (route) => route.abort());
 	await loadScene(B.page, AQUARIUM);
 	await install(B.page);
-	await B.page.evaluate(() => window.__aq.render());
-	await B.page.waitForTimeout(3000);
-	const offline = await B.page.evaluate(() => {
-		window.__aq.render();
-		return window.__aq.fallbackRoots().map((o) => ({
-			name: o.name,
-			current: window.__stores.lodGroup.lodGroupInfo(o.uuid)?.current,
-			trees: window.__stores.lodTrees.lodTreesOf(o).length,
-			failed: (window.__stores.lodGroup.lodGroupInfo(o.uuid)?.levels ?? []).filter((l) => l.status === 'failed').length
-		}));
-	});
+	// the first pack fetch on a fresh page waits for the asset cache to open first (OPFS + the legacy
+	// migration, 974e8be0) — wait for the failure to be REPORTED instead of a fixed 3 s; the statuses
+	// say which it was if it never comes (a slow `loading` vs a level never requested)
+	const offlineProbe = () =>
+		B.page.evaluate(() => {
+			window.__aq.render();
+			return window.__aq.fallbackRoots().map((o) => ({
+				name: o.name,
+				current: window.__stores.lodGroup.lodGroupInfo(o.uuid)?.current,
+				trees: window.__stores.lodTrees.lodTreesOf(o).length,
+				failed: (window.__stores.lodGroup.lodGroupInfo(o.uuid)?.levels ?? []).filter((l) => l.status === 'failed').length,
+				statuses: (window.__stores.lodGroup.lodGroupInfo(o.uuid)?.levels ?? []).map((l) => l.status)
+			}));
+		});
+	await h.eventually(offlineProbe, (o) => o.some((d) => d.failed > 0), '3.2 …and says why on the level (failed levels reported, not thrown)', 20000);
+	const offline = await offlineProbe();
 	h.check(offline.every((d) => d.current === 0 && d.trees === 0), '3.1 pack unreachable: every group draws its STAND-IN (LOD0) — the scene still has its fish, coral and plants');
-	h.check(offline.some((d) => d.failed > 0), '3.2 …and says why on the level (failed levels reported, not thrown)');
 	const offMove = await sample(B.page, () => window.__aq.world('Blue tang 1'), 4, 300);
 	h.check(Math.hypot(offMove[3][0] - offMove[0][0], offMove[3][2] - offMove[0][2]) > 0.1, '3.3 …and the stand-ins still swim');
 	if (SHOTS) await B.page.screenshot({ path: SHOTS + '-offline.png' });
diff --git a/tests/e2e/avatar-feet.test.cjs b/tests/e2e/avatar-feet.test.cjs
index 21449ee89..5496db9ba 100644
--- a/tests/e2e/avatar-feet.test.cjs
+++ b/tests/e2e/avatar-feet.test.cjs
@@ -89,7 +89,7 @@ h.run(async () => {
 	const hiRun = runSoles.length ? Math.max(...runSoles) : 0;
 	h.check(hiWalk <= FLOOR_TOL, `1.6 ...a walking stance foot stays on it (${walkSoles.length} walk samples, highest lowest-sole ${(hiWalk * 100).toFixed(1)} cm)`);
 	h.check(hiRun <= 0.13, `1.6b ...a run's flight phase stays a hop (${runSoles.length} run samples, highest ${(hiRun * 100).toFixed(1)} cm <= 13)`);
-	h.check(strides.every((s) => Math.abs(s.feet[1]) < 0.02), '1.7 the body origin stays on the floor while walking (no sinking)');
+	h.check(strides.every((s) => Math.abs(s.feet[1]) < 0.02), `1.7 the body origin stays on the floor while walking (no sinking; origin y per stride, cm: ${strides.map((s) => (s?.feet ? (s.feet[1] * 100).toFixed(1) : 'none')).join(' ')})`);
 
 	// ---- 2. a Character Controller on a raised floor (a 0.3 m step) ---------------------------
 	// a REAL Character Controller node (the flow runtime re-declares charControl from the graph
diff --git a/tests/e2e/battery.json b/tests/e2e/battery.json
index 5d5d97255..e7789eb6b 100644
--- a/tests/e2e/battery.json
+++ b/tests/e2e/battery.json
@@ -1,5 +1,5 @@
 {
-	"comment": "deps-auto: the e2e battery deps.yml runs in shards on GitHub-hosted runners (scripts/ci/battery.cjs). suites = name -> seconds on a runner (2x the desk time until a runner has measured it); skip = cannot run on a public runner (the reason); optional = runs and reports, does not gate (the reason); setup = extra install a suite needs. Refresh after an integrator battery: node scripts/ci/battery.cjs refresh --list <listA> --list <listB> --summary <summary.txt>... (RELEASING.md, Dependency updates). pc = the games (fps) and levels (shots) scripts/ci/pc-battery.sh measures on a desktop GPU.",
+	"comment": "deps-auto: the e2e battery deps.yml runs in shards on GitHub-hosted runners (scripts/ci/battery.cjs). suites = name -> seconds on a runner (2x the desk time until a runner has measured it); skip = cannot run on a public runner (the reason); what runs but does not gate is tests/e2e/quarantine.json (per check, owner + review date; test-health-1 replaced the old `optional` map); setup = extra install a suite needs. Refresh after an integrator battery: node scripts/ci/battery.cjs refresh --list <listA> --list <listB> --summary <summary.txt>... (RELEASING.md, Dependency updates). pc = the games (fps) and levels (shots) scripts/ci/pc-battery.sh measures on a desktop GPU.",
 	"refs": {
 		"modules": {"repo":"theprototype-app/modules","ref":"80fca17f7cd963cf698d6b5f29beaff14f28f9e1"},
 		"packs": {"repo":"theprototype-app/packs","ref":"360f31686652f0f9c7e240ff09785c6b6c60d678"},
@@ -15,40 +15,6 @@
 		"perf-beacon": "reads a hosts-mapped preview origin",
 		"timeline-export": "needs the built app (scripts/serve-build.cjs), not the dev server"
 	},
-	"optional": {
-		"animation-sync": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"behaviours": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"char-controller": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"collider-live": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"context-menu-redesign": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"edit-move-games": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"fb-water": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"flow-physics-actions": "flaky on every app/driver pair (deps-1 ab3, 2026-10-23)",
-		"flow-physics-nodes": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"game-loop-v4": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"game-sky-run": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"kit-instancing": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"lock-search": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"mesh-toolbox-redesign": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"model-preview": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"net-stress": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"panels": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"phone-sheets": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"physics-discoverability": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"physics-kinematic": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"scene-budget": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"scene-post": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"scene-post-effects": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"search-menus": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"select-41": "G4 flick timing flake (deps-1 ab3: 12/12 green on --local, red under load)",
-		"settings-layout": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"shader-sync": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"sound-node": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"themes": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"timeline-export": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"touch-actions": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)",
-		"water-migration": "red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23)"
-	},
 	"setup": {
 		"agent-bridge": "agent"
 	},
@@ -262,6 +228,7 @@
 		"modules-phone-jobs": 38,
 		"move-wire-shape": 150,
 		"multiselect-v2": 706,
+		"net-drop": 340,
 		"net-mesh": 30,
 		"net-peer-id": 120,
 		"net-stress": 120,
@@ -325,6 +292,7 @@
 		"quality-toast-preset": 106,
 		"race-vr-shadows": 32,
 		"race-vr-shadows-iwer": 26,
+		"reload-memory": 190,
 		"reset-windows": 26,
 		"resize-observer-loop": 818,
 		"ro-loop-guard": 538,
diff --git a/tests/e2e/behaviours.test.cjs b/tests/e2e/behaviours.test.cjs
index f942d412b..5d6c379a2 100644
--- a/tests/e2e/behaviours.test.cjs
+++ b/tests/e2e/behaviours.test.cjs
@@ -121,6 +121,10 @@ h.run(async () => {
 		s.behaviourViewOpen.set({ id: i, graphId: 'scene' });
 	}, wid);
 	await B.page.waitForSelector('#behaviour-view [data-bview-kind="state"]', { timeout: 10000 });
+	// the glow is "changed since this view's FIRST live tick" — on the authority the died handler
+	// fires the moment we kill, so a kill that beats B's first 100 ms tick lands in its baseline
+	// and never glows (0 of 10 samples). Live values on the state nodes = that tick has run.
+	await h.eventually(() => B.page.$$eval('#behaviour-view [data-bview-kind="state"] [data-bview-value]', (els) => els.map((e) => e.textContent?.trim())), (v) => v.join(',') === '1,2', 'B\'s view is live before the kill (wave 1, alive 2)', 5000);
 	const SAMPLE = () =>
 		new Promise((resolve) => {
 			/** @type {any[]} */
diff --git a/tests/e2e/char-controller.test.cjs b/tests/e2e/char-controller.test.cjs
index 8407b24c7..15bb36799 100644
--- a/tests/e2e/char-controller.test.cjs
+++ b/tests/e2e/char-controller.test.cjs
@@ -110,16 +110,53 @@ const values = (page) =>
 const dist = (a, b) => Math.hypot(a.x - b.x, a.y - b.y, a.z - b.z);
 const distXZ = (a, b) => Math.hypot(a.x - b.x, a.z - b.z);
 
-/** Hold a key for `ms` and report how far the rig travelled. */
+/** Hold a key for `ms` and report how far the rig travelled — and over how many FRAMES.
+ * Fly moves a fixed step per frame (PointerLockControls translates by `speed` each tick),
+ * so a wall-clock window measures the frame rate as much as the speed: on software GL the
+ * same 1200 ms was 20 frames once and 10 the next (2.000 vs 1.000 units). `perFrame` (the
+ * median step over the frames in which the rig actually moved, from an in-page rAF
+ * sampler) is the number the speed comparisons below read. */
 async function travel(page, code, ms) {
+	await page.evaluate(() => {
+		let cam = null;
+		window.__stores.playerCam.subscribe((c) => (cam = c))();
+		const V = window.__stores.THREE.Vector3;
+		const w0 = cam ? cam.getWorldPosition(new V()) : null;
+		const s = (window.__travelSampler = { frames: 0, on: true, start: w0, last: w0, moved: 0, steps: [] });
+		const step = () => {
+			if (!s.on) return;
+			const w = cam ? cam.getWorldPosition(new V()) : null;
+			if (w && s.last && w.distanceToSquared(s.last) > 1e-10) {
+				s.frames++;
+				s.moved += w.distanceTo(s.last);
+				s.steps.push(w.distanceTo(s.last));
+			}
+			s.last = w;
+			requestAnimationFrame(step);
+		};
+		requestAnimationFrame(step);
+	});
 	const before = await camWorld(page);
 	await page.keyboard.down(code);
 	await page.waitForTimeout(ms);
 	await page.keyboard.up(code);
 	await page.waitForTimeout(150);
 	const after = await camWorld(page);
-	return { before, after, moved: dist(before, after), movedXZ: distXZ(before, after) };
+	// distance and frame count from the SAME sampler window — reading `before` separately put a frame
+	// on one side of the count and not the other (0.092 vs 0.100 per frame over 5)
+	const sampled = await page.evaluate(() => {
+		window.__travelSampler.on = false;
+		return { frames: window.__travelSampler.frames, moved: window.__travelSampler.moved, steps: window.__travelSampler.steps };
+	});
+	const moved = dist(before, after);
+	const frames = sampled.frames;
+	// the MEDIAN step: one settling frame (the first after the controller goes, a grounding nudge) is
+	// a quarter of the sample at ~3 fps and moved the mean 10 %; the speed is what most frames do
+	const sorted = [...sampled.steps].sort((a, b) => a - b);
+	const median = sorted.length ? (sorted.length % 2 ? sorted[(sorted.length - 1) / 2] : (sorted[sorted.length / 2 - 1] + sorted[sorted.length / 2]) / 2) : 0;
+	return { before, after, moved, movedXZ: distXZ(before, after), frames, perFrame: median };
 }
+const perFrameText = (t) => `${t.perFrame.toFixed(4)}/frame (median) over ${t.frames}`;
 
 // ---- driving the graph ------------------------------------------------------
 // THE SCOPE RESET IS LOAD-BEARING (logic-nodes documents the cost): the editor's scope
@@ -197,12 +234,12 @@ h.run(async () => {
 	const WINDOW = 1200;
 	const builtin = await travel(A.page, 'KeyW', WINDOW);
 	h.check(builtin.moved > 0.5, `built-in fly moves the rig (${builtin.moved.toFixed(3)} units)`);
-	// a 1.2s window at 60fps is ~72 frames x 0.1 = ~7.2 units; a wide band, because the
-	// point here is only that the number is the RIGHT ORDER (a stuck or doubled speed
-	// would fall outside it) and the tight comparison is the A/B below
+	// fly at the default 0.1 is 0.1 per moving frame; the band only says the number is the
+	// RIGHT ORDER (a stuck or doubled speed falls outside it) and the tight comparison is the
+	// A/B below
 	h.check(
-		builtin.moved > 2 && builtin.moved < 12,
-		`and by about speed x frames (${builtin.moved.toFixed(2)} units in ${WINDOW}ms)`
+		builtin.perFrame > 0.07 && builtin.perFrame < 0.14,
+		`and by about speed x frames (${builtin.moved.toFixed(2)} units, ${perFrameText(builtin)})`
 	);
 	const stillNull = await charDebug(A.page);
 	h.check(stillNull.control === null, 'flying with no controller node declares nothing');
@@ -223,11 +260,11 @@ h.run(async () => {
 	h.check(declared.moveSpeed === null, 'with no override yet, so the param is what moves you');
 
 	const noded = await travel(A.page, 'KeyW', WINDOW);
-	const gap = Math.abs(noded.moved - builtin.moved) / builtin.moved;
+	const gap = Math.abs(noded.perFrame - builtin.perFrame) / builtin.perFrame;
 	h.check(
 		gap < 0.05,
 		`PARITY: fly@0.1 as a node matches the built-in within 5% ` +
-			`(${builtin.moved.toFixed(3)} vs ${noded.moved.toFixed(3)}, ${(gap * 100).toFixed(1)}% apart)`
+			`(${perFrameText(builtin)} vs ${perFrameText(noded)}, ${(gap * 100).toFixed(1)}% apart)`
 	);
 
 	// the guard has to be able to FAIL: a different authored speed must move you a
@@ -239,10 +276,10 @@ h.run(async () => {
 		'the speed param reaches the store'
 	);
 	const faster = await travel(A.page, 'KeyW', WINDOW);
-	const ratio = faster.moved / noded.moved;
+	const ratio = faster.perFrame / noded.perFrame;
 	h.check(
 		ratio > 2.4 && ratio < 3.6,
-		`3x the speed is ~3x the distance (${noded.moved.toFixed(2)} -> ${faster.moved.toFixed(2)}, x${ratio.toFixed(2)})`
+		`3x the speed is ~3x the distance (${perFrameText(noded)} -> ${perFrameText(faster)}, x${ratio.toFixed(2)})`
 	);
 
 	// =========================================================================
@@ -502,10 +539,10 @@ h.run(async () => {
 		'and the other Move Speed node reads the new value, not its own param'
 	);
 	const fast = await travel(A.page, 'KeyW', WINDOW);
-	const speedRatio = fast.moved / slow.moved;
+	const speedRatio = fast.perFrame / slow.perFrame;
 	h.check(
 		speedRatio > 2.6 && speedRatio < 4.4,
-		`which actually MOVES you faster (${slow.moved.toFixed(2)} -> ${fast.moved.toFixed(2)}, x${speedRatio.toFixed(2)})`
+		`which actually MOVES you faster (${perFrameText(slow)} -> ${perFrameText(fast)}, x${speedRatio.toFixed(2)})`
 	);
 
 	// the scroll wheel writes through the same store while a controller is declared
@@ -630,11 +667,12 @@ h.run(async () => {
 		landedOnB && theirs && theirs.x === 0 && theirs.y === 0,
 		`and the PEER holding the same graph reads 0 — local by design, never streamed (${JSON.stringify(theirs)})`
 	);
-	await A.page.waitForTimeout(300);
-	const released = (await values(A.page)).mv?.__handles ?? null;
-	h.check(
-		released && released.x === 0 && released.y === 0,
-		`releasing the keys returns it to zero (${JSON.stringify(released)})`
+	// the node value refreshes on the graph's next tick — a fixed 300 ms is a handful of frames
+	// on software GL, so wait for the zero (still red if it never comes)
+	await h.eventually(
+		() => values(A.page).then((v) => v.mv?.__handles ?? null),
+		(r) => !!r && r.x === 0 && r.y === 0,
+		'releasing the keys returns it to zero'
 	);
 
 	// =========================================================================
@@ -648,12 +686,15 @@ h.run(async () => {
 		(d) => d.control === null && d.moveSpeed === null,
 		'deleting the node clears charControl AND the speed override'
 	);
+	// level again, as section 1 did: the sections between turned the camera, and fly moves along its
+	// forward axis — a pitched rig measured 0.09/frame (0.1 x cos 26 deg) for the same 0.1 speed
+	await levelCamera(A.page);
 	const restored = await travel(A.page, 'KeyW', WINDOW);
-	const backGap = Math.abs(restored.moved - builtin.moved) / builtin.moved;
+	const backGap = Math.abs(restored.perFrame - builtin.perFrame) / builtin.perFrame;
 	h.check(
 		backGap < 0.08,
 		`PARITY RESTORED: movement matches the very first measurement ` +
-			`(${builtin.moved.toFixed(3)} vs ${restored.moved.toFixed(3)}, ${(backGap * 100).toFixed(1)}% apart)`
+			`(${perFrameText(builtin)} vs ${perFrameText(restored)}, ${(backGap * 100).toFixed(1)}% apart)`
 	);
 	const noWalker = await charDebug(A.page);
 	h.check(
diff --git a/tests/e2e/code-sidebars.test.cjs b/tests/e2e/code-sidebars.test.cjs
index 0b8cf30ac..8b01db19d 100644
--- a/tests/e2e/code-sidebars.test.cjs
+++ b/tests/e2e/code-sidebars.test.cjs
@@ -471,8 +471,11 @@ h.run(async () => {
 	await page.locator('#code-ws-confirm-all-discard').click();
 	await page.waitForTimeout(400);
 	h.check((await read(page, 'codeWorkspaceClose')) === true && (await read(page, 'codeWorkspace.codeTabs')).every((t) => t.code === t.saved || t.readOnly), 'S7: Don\'t save closes and throws the edits away');
-	await S(page, () => window.__stores.codeWorkspace.openCode({ source: 'script', ref: { nodeId: 'cs-undo', graphId: 'scene' } }));
-	await page.waitForTimeout(600);
+	const reTab = await S(page, () => window.__stores.codeWorkspace.openCode({ source: 'script', ref: { nodeId: 'cs-undo', graphId: 'scene' } }));
+	// 50 Y1 (6e6c95ca): "Don't save" discards THIS view and leaves the room's shared buffer alone, so the
+	// reopen rejoins the edits; revert the shared copy (for everyone) to reach "nothing unsaved"
+	await S(page, (id) => window.__stores.codeWorkspace.reloadCodeTab(id), reTab);
+	await h.eventually(() => read(page, 'codeWorkspace.codeTabs'), (tabs) => tabs.every((t) => t.code === t.saved || t.readOnly), 'S7 (premise) after the revert nothing is unsaved');
 	h.check((await S(page, () => {
 		const ev = new Event('beforeunload', { cancelable: true });
 		window.dispatchEvent(ev);
diff --git a/tests/e2e/collider-live.test.cjs b/tests/e2e/collider-live.test.cjs
index 84371094e..c1345f2cf 100644
--- a/tests/e2e/collider-live.test.cjs
+++ b/tests/e2e/collider-live.test.cjs
@@ -55,7 +55,16 @@ h.run(async () => {
 		window.__ball.userData.physics = { ...window.__ball.userData.physics, collider: 'box' };
 		window.__stores.physics.physicsShapeChanged(window.__ball.uuid);
 	});
-	await A.page.waitForTimeout(2500); // let the box scrub off the roll speed
+	// let the box scrub off the roll speed — by its SPEED, not a fixed 2500 ms (test-health-1): physics
+	// steps at most 8 x 1/60 s per frame, so on a software-GL page (~2-5 fps) 2.5 s of wall clock is
+	// well under a second of simulation and the box was still sliding (dx 0.87). A sphere collider
+	// keeps rolling down the ramp, so it never gets here.
+	const speed = () =>
+		A.page.evaluate(() => {
+			const v = window.__stores.physics.physicsDebug().find((b) => b.uuid === window.__ball.uuid)?.linvel;
+			return v ? Math.hypot(v.x, v.y, v.z) : null;
+		});
+	await h.eventually(speed, (v) => v !== null && v < 0.05, 'the box collider scrubs the roll to rest', 30000);
 	const still = await A.page.evaluate(async () => {
 		const x0 = window.__ball.position.x;
 		await new Promise((r) => setTimeout(r, 1200));
diff --git a/tests/e2e/diagnostics.test.cjs b/tests/e2e/diagnostics.test.cjs
index 3165ad7a3..d477462a8 100644
--- a/tests/e2e/diagnostics.test.cjs
+++ b/tests/e2e/diagnostics.test.cjs
@@ -42,6 +42,13 @@ h.run(async () => {
 	h.check(/line 319\b/.test(ring.last), `the NEWEST line is kept: ${ring.last}`);
 
 	// ---- 2. the bundle, and the registered section --------------------------------
+	// test-health-1: the peer id is empty until the signaling server hands one out, which on a
+	// public CI runner (the public PeerJS cloud) can take longer than this suite's first seconds;
+	// a section that captured an IMPORT instead of reading the store stays empty forever, so
+	// waiting for it keeps the counterfactual.
+	await page
+		.waitForFunction(() => (window.__stores.diagnostics.bundle().sections?.session?.peerId ?? '').length > 0, null, { timeout: 30000 })
+		.catch(() => {});
 	const bundle = await page.evaluate(() => window.__stores.diagnostics.bundle());
 	h.check(
 		!!bundle.version && !!bundle.at && typeof bundle.ua === 'string',
diff --git a/tests/e2e/fixtures/lock/search.json b/tests/e2e/fixtures/lock/search.json
index eec24d57d..c303cecd5 100644
--- a/tests/e2e/fixtures/lock/search.json
+++ b/tests/e2e/fixtures/lock/search.json
@@ -1,5 +1,5 @@
 {
-	"recordedAt": "2026-10-22T17:48:57.949Z",
+	"recordedAt": "2026-10-24T15:10:13.838Z",
 	"settings": {
 		"Theme": {
 			"rows": [
@@ -1776,10 +1776,12 @@
 		},
 		"Storage used": {
 			"rows": [
+				"Cache size limit",
 				"Storage used"
 			],
 			"sections": [
-				"Explorer"
+				"Explorer",
+				"Storage"
 			]
 		},
 		"Optimize big models automatically": {
@@ -2971,11 +2973,13 @@
 		"network": {
 			"rows": [
 				"Apply changes",
+				"Cached downloads",
 				"Session size",
 				"Signaling server",
 				"Statistics card"
 			],
 			"sections": [
+				"Storage",
 				"VR",
 				"Connection"
 			]
@@ -3105,18 +3109,23 @@
 		},
 		"disk": {
 			"rows": [
+				"Storage breakdown",
 				"Storage used"
 			],
 			"sections": [
-				"Explorer"
+				"Explorer",
+				"Storage"
 			]
 		},
 		"quota": {
 			"rows": [
+				"Cache size limit",
+				"Storage breakdown",
 				"Storage used"
 			],
 			"sections": [
-				"Explorer"
+				"Explorer",
+				"Storage"
 			]
 		},
 		"toolbar": {
@@ -3332,6 +3341,7 @@
 				"Paste at the cursor",
 				"Pinch zoom",
 				"Play / Enter VR·AR (right-click the play button for modes)",
+				"Play here — start from the editor camera",
 				"Previous element mode",
 				"Push to talk while the mic toggle is off",
 				"Race: back on the road",
@@ -3470,6 +3480,8 @@
 		},
 		"files": {
 			"rows": [
+				"Cache size limit",
+				"Cached downloads",
 				"Delete without asking",
 				"Deleted files log",
 				"Download shared files automatically",
@@ -3484,7 +3496,8 @@
 				"Who can unshare a file"
 			],
 			"sections": [
-				"Explorer"
+				"Explorer",
+				"Storage"
 			]
 		},
 		"library": {
@@ -3740,6 +3753,7 @@
 				"Object list: show / bring to front / hide",
 				"Paste at the cursor",
 				"Play / Enter VR·AR (right-click the play button for modes)",
+				"Play here — start from the editor camera",
 				"Previous element mode",
 				"Push to talk while the mic toggle is off",
 				"Race: back on the road",
@@ -3862,6 +3876,7 @@
 				"Object list: show / bring to front / hide",
 				"Paste at the cursor",
 				"Play / Enter VR·AR (right-click the play button for modes)",
+				"Play here — start from the editor camera",
 				"Previous element mode",
 				"Push to talk while the mic toggle is off",
 				"Race: back on the road",
@@ -3985,6 +4000,7 @@
 				"Object list: show / bring to front / hide",
 				"Paste at the cursor",
 				"Play / Enter VR·AR (right-click the play button for modes)",
+				"Play here — start from the editor camera",
 				"Previous element mode",
 				"Push to talk while the mic toggle is off",
 				"Race: back on the road",
@@ -4419,6 +4435,7 @@
 		},
 		"ai": {
 			"rows": [
+				"Cached downloads",
 				"Colocation probe",
 				"Compress textures (KTX2)",
 				"Download shared files automatically",
@@ -4444,6 +4461,7 @@
 				"Reset tips",
 				"Reverse trackpad pan",
 				"Stance",
+				"Storage breakdown",
 				"Storage used",
 				"Teleport",
 				"Texture threshold",
@@ -4457,6 +4475,7 @@
 				"Shortcuts",
 				"Scene",
 				"Explorer",
+				"Storage",
 				"Import",
 				"Export",
 				"VR",
diff --git a/tests/e2e/flow-physics-actions.test.cjs b/tests/e2e/flow-physics-actions.test.cjs
index d4e2748a3..76a18000f 100644
--- a/tests/e2e/flow-physics-actions.test.cjs
+++ b/tests/e2e/flow-physics-actions.test.cjs
@@ -244,14 +244,18 @@ h.run(async () => {
 	console.log('\n=== 2. Set Velocity ===');
 
 	await page.evaluate(() => window.__stores.physics.stopSimulation());
+	// test-health-1: a TOGGLE holds the trigger, as 1.4 does. A held Key Press is re-stamped AFTER
+	// the physics actions read it in runTick, so on a page slower than its 0.3 s pulse (~3 fps,
+	// software GL) the key read 0 every frame and this section measured -0.00 m/s; what 2.x is
+	// about is Set Velocity's continuous mode, not the key (the key path stays in 1.x and 6.x).
 	await setGraph(
 		page,
 		[
-			node('key1', 'keypress', { code: 'KeyR', pulse: 0.3 }),
+			node('tog2', 'toggle', { on: false }),
 			node('sv1', 'setvelocity', { mode: 'continuous', x: 2, y: 0, z: 0 }, 200),
 			node('sel1', 'objectselector', { selected: box }, 400)
 		],
-		[edge('key1', 'sv1', 'trigger'), edge('sv1', 'sel1')]
+		[edge('tog2', 'sv1', 'trigger'), edge('sv1', 'sel1')]
 	);
 	await page.evaluate(
 		(uuid) => {
@@ -267,16 +271,12 @@ h.run(async () => {
 	await page.evaluate(() => window.__stores.physics.toggleSimulation());
 	await page.waitForTimeout(1200);
 
-	await page.evaluate(() => {
-		document.dispatchEvent(new KeyboardEvent('keydown', { code: 'KeyR', bubbles: true }));
-	});
+	await page.evaluate(() => window.__stores.nodesHandler.setNodeData('tog2', { on: true }));
 	await page.waitForTimeout(1400); // let it reach the speed before sampling it
 	const held1 = (await bodyOf(page, box))?.linvel?.x ?? 0;
 	await page.waitForTimeout(700);
 	const held2 = (await bodyOf(page, box))?.linvel?.x ?? 0;
-	await page.evaluate(() => {
-		document.dispatchEvent(new KeyboardEvent('keyup', { code: 'KeyR', bubbles: true }));
-	});
+	await page.evaluate(() => window.__stores.nodesHandler.setNodeData('tog2', { on: false }));
 	// the velocity is re-written once per FLOW TICK, and friction bleeds it between
 	// ticks, so the observable property is a STEADY speed rather than exactly the
 	// dialled number
@@ -475,7 +475,11 @@ h.run(async () => {
 			return original(message);
 		};
 	});
-	const beforeHopY = (await posOf(B.page, box))[1];
+	// test-health-1: the box reaches B through the object sync, which can land well after the graph
+	// (6.3) on a software-GL page — read it once it is there (a box that never arrives is a named red
+	// here, not a TypeError that ended the suite at this line)
+	await h.eventually(() => posOf(B.page, box), (p) => Array.isArray(p), '6.5a (premise) the late joiner has the box', 30000);
+	const beforeHopY = (await posOf(B.page, box))?.[1] ?? 0;
 	// Drive the trigger through applyNodeTrigger — the SAME entry point a Key
 	// Press produces (flowRuntime calls exactly this, with replicate: true), so
 	// the path under test is unchanged: rising edge -> updatePhysicsActions ->
@@ -491,14 +495,42 @@ h.run(async () => {
 	// or these nodes' logic. Unexplained, and reported as such rather than
 	// papered over — the same key press works before the join and in every
 	// single-peer section.
+	// test-health-1: stamped on the SESSION clock, the one flowRuntime stamps with (syncedNow). The
+	// raw Date.now() this used to pass is a different clock once a peer is in: the join merges B's
+	// trigger log, which sets A's history epoch in session time, so a raw stamp behind it is refused
+	// as somebody else's history (and sits outside the pulse window) — 6.5 red, no hop.
 	await page.evaluate(() => {
-		window.__stores.flowRuntime.applyNodeTrigger('key6', (Date.now() % 86400000) / 1000, true);
+		const s = window.__stores;
+		s.flowRuntime.applyNodeTrigger('key6', (s.connectionState.sessionNow() % 86400000) / 1000, true);
 	});
+	let hopped = false;
 	await h.eventually(
 		async () => (await posOf(page, box))[1],
-		(y) => y > 0.7,
+		(y) => (hopped = y > 0.7),
 		'6.5 (premise) the trigger hops the box on A, the peer running the world'
 	);
+	// a red 6.5 says WHY: which clock the stamp is on, the history epoch, the stamp held
+	if (!hopped)
+		console.log(
+			'  6.5 clocks: ' +
+				JSON.stringify(
+					await page.evaluate(() => {
+						const s = window.__stores;
+						let t = {};
+						s.flowTriggers?.subscribe?.((v) => (t = v))?.();
+						let sim = null;
+						s.physics.simulating.subscribe((v) => (sim = v))();
+						return {
+							rawNow: (Date.now() % 86400000) / 1000,
+							sessionNow: (s.connectionState.sessionNow() % 86400000) / 1000,
+							epoch: s.flowRuntime.triggerHistoryEpoch(),
+							key6: t?.key6 ?? null,
+							simulating: sim,
+							initiator: s.physics.isInitiator?.() ?? null
+						};
+					})
+				)
+		);
 	await h.eventually(
 		async () => (await posOf(B.page, box))[1],
 		(y) => y > beforeHopY + 0.2,
@@ -510,7 +542,8 @@ h.run(async () => {
 	// is that the physics ACTION nodes add nothing of their own
 	const unexpected = types.filter(
 		(t) =>
-			!['move', 'nodetrigger', 'nodechange', 'nodesync', 'nodes', 'simulate', 'objectParameters'].includes(
+			// + `camera`: the presence stream (where a peer is looking), which flows whenever a peer is in
+			!['move', 'nodetrigger', 'nodechange', 'nodesync', 'nodes', 'simulate', 'objectParameters', 'camera'].includes(
 				t
 			)
 	);
diff --git a/tests/e2e/flow-physics-nodes.test.cjs b/tests/e2e/flow-physics-nodes.test.cjs
index 2e25198b6..3a82a6e44 100644
--- a/tests/e2e/flow-physics-nodes.test.cjs
+++ b/tests/e2e/flow-physics-nodes.test.cjs
@@ -45,6 +45,10 @@ h.run(async () => {
 		base.position.set(6, 0.5, 0);
 		rotor.position.set(6, 2.2, 0);
 		rotor.userData.physics = { mode: 'dynamic', mass: 1 };
+		// test-health-1: since 95df3a66 ("fun-by-default primitives") every created box is DYNAMIC, so
+		// the Base this scene means as an anchor had a body and the "refused on a non-dynamic body"
+		// check below found one; say it is the static anchor the comment above describes
+		base.userData.physics = { mode: 'static' };
 		const peer = await new Promise((r) => window.__stores.peers.subscribe(r)());
 		[spinner, base, rotor].forEach((o) => {
 			peer.send({ type: 'move', uuid: o.uuid, pos: o.position.toArray(), rot: [0, 0, 0], scale: [1, 1, 1] });
diff --git a/tests/e2e/game-loop-v4.test.cjs b/tests/e2e/game-loop-v4.test.cjs
index 1d6c463f1..0126fea47 100644
--- a/tests/e2e/game-loop-v4.test.cjs
+++ b/tests/e2e/game-loop-v4.test.cjs
@@ -90,6 +90,21 @@ h.run(async () => {
 	await makeBox(B);
 	const lobby = await B.page.evaluate(() => window.__stores.levels.saveSceneAsLevel('Lobby'));
 	h.check(!!lobby?.hash, 'the Lobby scene is in the project');
+	// test-health-1: saving the cleared world as Lobby MOVES B's room (R22 round 30/34: rooms are
+	// content partitions, a save names the room) while A still stands in Hunt — so B's node and
+	// edge below were withheld from A as "elsewhere" and the travel never reached it. A joins the
+	// Lobby by name first, the way a player would.
+	await A.page.evaluate(() => window.__stores.levels.travelToScene('Lobby'));
+	await h.eventually(
+		() => A.page.evaluate(() => {
+			let c;
+			window.__stores.levels.currentLevel.subscribe((v) => (c = v))();
+			return c?.name ?? '';
+		}),
+		(n) => n === 'Lobby',
+		'premise: A stands in the Lobby with B',
+		30000
+	);
 	// the travel NODE in name mode, pulsed on B, moves BOTH peers to the CURRENT Hunt
 	const node = await B.page.evaluate(() => {
 		const s = window.__stores;
diff --git a/tests/e2e/game-sky-run.test.cjs b/tests/e2e/game-sky-run.test.cjs
index ba2c1787a..51d385e1a 100644
--- a/tests/e2e/game-sky-run.test.cjs
+++ b/tests/e2e/game-sky-run.test.cjs
@@ -96,7 +96,9 @@ h.run(async () => {
 		return cam.getWorldPosition(new s.THREE.Vector3()).toArray().map((n) => +n.toFixed(2));
 	});
 	const vignette = await page.evaluate(() => { let v; window.__stores.gameKit.gameSettings?.gameSettingValues?.subscribe((x) => (v = x))(); return v?.vignette ?? null; });
-	h.check(vignette === true, `the comfort vignette defaults ON for this game (${vignette})`);
+	// test-health-1: 53-play phase 6 (e16c7413) made the vignette a LEVEL (default/off/low/high) and
+	// maps the module's `true` to 'high' (gameSettings aliases), so ON reads 'high' now
+	h.check(vignette === 'high', `the comfort vignette defaults ON (high) for this game (${vignette})`);
 	h.check(eye0[1] > 12.5 && Math.abs(eye0[0]) < 3, `Play put the player on stage 1's start pad, up in the sky (${eye0})`);
 
 	console.log('\n=== 3. a scripted run of stage 1 ===');
diff --git a/tests/e2e/helpers.cjs b/tests/e2e/helpers.cjs
index b39fbda66..740f0cc68 100644
--- a/tests/e2e/helpers.cjs
+++ b/tests/e2e/helpers.cjs
@@ -252,6 +252,32 @@ async function setupPageQuiet(browser, name, others, options = {}) {
 
 /** Connect `from` to `to` (approve on `to`), then let the mesh settle. */
 async function connect(from, to, settleMs = 9000) {
+	// test-health-1: dial the id the page holds NOW. setupPage reads it before the signaling link
+	// has opened, and a page whose first id the server reports as taken re-rolls it
+	// (peerHandler 'unavailable-id') — behaviours dialled the stale id and waited 30 s for an
+	// Approve card that could never come. Wait (bounded) for both links, then re-read both ids.
+	for (const peer of [from, to]) {
+		const live = await peer.page
+			.waitForFunction(
+				() => {
+					/** @type {any} */ let p;
+					window.__stores.peers.subscribe((v) => (p = v))();
+					return p?.peer?.open && p.peer.id ? p.peer.id : false;
+				},
+				null,
+				{ timeout: 20000 }
+			)
+			.then((r) => r.jsonValue())
+			.catch(() => null);
+		if (live && live !== peer.id) {
+			console.log(`[helpers] ${peer.id} is ${live} now (the id was re-rolled)`);
+			peer.id = live;
+		}
+	}
+	// 44 M14: on a narrow window (net-stress's 800 px) the floating pill is SQUEEZED to its status dot,
+	// and the dial input shows only after a tap on it — press it first when it is what is there
+	const squeezedDot = from.page.locator('#connect-squeeze-dot');
+	if (await squeezedDot.isVisible().catch(() => false)) await squeezedDot.click();
 	await step(from, 'fill the peer id', () =>
 		from.page.locator('input[placeholder="Enter peer ID to connect"]').fill(to.id)
 	);
@@ -534,9 +560,9 @@ async function centeredClip(peer, world, size = 360) {
  * @param {any} page @param {Buffer} before @param {Buffer} after @param {number} [threshold]
  * @returns {Promise<{changed: number, total: number, fraction: number, mean: number, max: number, width: number, height: number, error?: string}>}
  */
-async function frameDelta(page, before, after, threshold = 6) {
+async function frameDelta(page, before, after, threshold = 6, skipTop = 0) {
 	return page.evaluate(
-		async ({ a, b, threshold, decodeSource }) => {
+		async ({ a, b, threshold, skipTop, decodeSource }) => {
 			const decode = eval(decodeSource);
 			const A = await decode(a);
 			const B = await decode(b);
@@ -545,7 +571,8 @@ async function frameDelta(page, before, after, threshold = 6) {
 			let changed = 0;
 			let sum = 0;
 			let max = 0;
-			for (let i = 0; i < A.data.length; i += 4) {
+			// skipTop: rows left out of the comparison (chrome a reference image captured over the canvas)
+			for (let i = skipTop * A.width * 4; i < A.data.length; i += 4) {
 				const delta =
 					Math.abs(A.data[i] - B.data[i]) +
 					Math.abs(A.data[i + 1] - B.data[i + 1]) +
@@ -554,7 +581,7 @@ async function frameDelta(page, before, after, threshold = 6) {
 				sum += delta;
 				if (delta > max) max = delta;
 			}
-			const total = A.data.length / 4;
+			const total = A.data.length / 4 - skipTop * A.width;
 			return {
 				changed,
 				total,
@@ -565,7 +592,7 @@ async function frameDelta(page, before, after, threshold = 6) {
 				height: A.height
 			};
 		},
-		{ a: before.toString('base64'), b: after.toString('base64'), threshold, decodeSource: DECODE_FN }
+		{ a: before.toString('base64'), b: after.toString('base64'), threshold, skipTop, decodeSource: DECODE_FN }
 	);
 }
 
diff --git a/tests/e2e/hud-editor.test.cjs b/tests/e2e/hud-editor.test.cjs
index ebcf67712..e84997b11 100644
--- a/tests/e2e/hud-editor.test.cjs
+++ b/tests/e2e/hud-editor.test.cjs
@@ -19,11 +19,12 @@ h.run(async () => {
 	const page = A.page;
 	await page.waitForFunction(() => !!window.__stores?.hudDocs, { timeout: 30000 });
 
-	// ---- 1. it is the 6th FLOW_FAMILY member, opened from the real add-menu --
+	// ---- 1. it is a FLOW_FAMILY member, opened from the real add-menu --------
 	const family = await page.evaluate(() => window.__stores.bottomDock.FLOW_FAMILY);
 	h.check(
-		family.length === 6 && family[5] === 'hud',
-		`'hud' is the sixth FLOW_FAMILY member (${JSON.stringify(family)})`
+		// a position check broke when the timeline joined the family after it (896cdb93)
+		family.includes('hud'),
+		`'hud' is a FLOW_FAMILY member (${JSON.stringify(family)})`
 	);
 	const title = await page.evaluate(() => window.__stores.bottomDock.DOCK_TITLES.hud);
 	h.check(title === 'HUD editor', `and has a dock title (${title})`);
diff --git a/tests/e2e/knock-physics.test.cjs b/tests/e2e/knock-physics.test.cjs
index 469bbe67b..46bb881a2 100644
--- a/tests/e2e/knock-physics.test.cjs
+++ b/tests/e2e/knock-physics.test.cjs
@@ -392,7 +392,7 @@ h.run(async () => {
 		'2.3 (premise) B sees the ball parked at (0,1,0)'
 	);
 
-	const remote = await B.page.evaluate((uuid) => {
+	const remote = await B.page.evaluate(async (uuid) => {
 		const k = window.__stores.knock;
 		k.dropProbe('b');
 		let hits = 0;
@@ -404,7 +404,17 @@ h.run(async () => {
 		let group = null;
 		window.__stores.objectsGroup.subscribe((v) => (group = v))();
 		const object = group.getObjectByProperty('uuid', uuid);
-		return { hits, predicting: k.knockDebug().predictions.includes(uuid), x0: object.position.x, local: k.lastHitOf(uuid) };
+		const x0 = object.position.x;
+		const predicting = k.knockDebug().predictions.includes(uuid);
+		// the prediction moves the ball once per RENDERED frame and is withdrawn after 400 ms of wall
+		// clock (PREDICT_MAX_MS): at ~4 fps a fixed 60 ms read lands between frames or after the
+		// withdrawal (exactly 0.000). Take the furthest it got over B's next few frames.
+		let advanced = 0;
+		for (let i = 0; i < 6; i++) {
+			await new Promise((r) => requestAnimationFrame(r));
+			advanced = Math.max(advanced, object.position.x - x0);
+		}
+		return { hits, predicting, x0, advanced, local: k.lastHitOf(uuid) };
 	}, ball);
 	h.check(remote.hits === 1, '2.4 B\'s 4 m/s sweep registers one knock locally');
 	const message = await B.page.evaluate(() => window.__sent.find((m) => m.type === 'hit') ?? null);
@@ -434,26 +444,17 @@ h.run(async () => {
 	h.check(logs[0]?.by === B.id && logs[1]?.by === B.id, '2.10 both logs name B as the hitter (A says ' + logs[0]?.by + ')');
 	h.check(logs[0] && logs[1] && logs[0].at === logs[1].at && Math.abs(logs[0].speed - logs[1].speed) < 1e-6, '2.11 ...with the SAME stamp and speed on both peers (A2 keys onhit by that stamp)');
 
-	const advanced = await B.page.evaluate(
-		([uuid, x0]) =>
-			new Promise((resolve) =>
-				setTimeout(() => {
-					let group = null;
-					window.__stores.objectsGroup.subscribe((v) => (group = v))();
-					const object = group.getObjectByProperty('uuid', uuid);
-					resolve(object.position.x - x0);
-				}, 60)
-			),
-		[ball, remote.x0]
-	);
-	h.check(advanced > 0.04, '2.12 within 60 ms B\'s rendered ball has moved along the hit (' + advanced.toFixed(3) + ' m) — prediction, or authority already landing on it');
+	const advanced = remote.advanced;
+	h.check(advanced > 0.04, '2.12 within B\'s next rendered frames its ball has moved along the hit (' + advanced.toFixed(3) + ' m) — prediction, or authority already landing on it');
 	await h.eventually(
 		async () => {
 			const a = await posOf(A.page, ball);
 			const b = await posOf(B.page, ball);
-			return Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
+			return { ax: a[0], gap: Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]) };
 		},
-		(gap) => gap < 0.3,
+		// agreement must come over AUTHORITY's moves (which also end the prediction, 2.14): while A's ball
+		// has not moved yet, both peers reading x≈0 is not convergence
+		(r) => Math.abs(r.ax - remote.x0) > 0.5 && r.gap < 0.3,
 		'2.13 the two peers converge on where the ball came to rest, over the ordinary move stream',
 		12000
 	);
diff --git a/tests/e2e/mesh-toolbox-redesign.test.cjs b/tests/e2e/mesh-toolbox-redesign.test.cjs
index 08bcc31b3..4262d0be5 100644
--- a/tests/e2e/mesh-toolbox-redesign.test.cjs
+++ b/tests/e2e/mesh-toolbox-redesign.test.cjs
@@ -826,7 +826,7 @@ h.run(async () => {
 		const r = el.getBoundingClientRect();
 		const body = el.querySelector('.toolbox-body');
 		const grip = el.querySelector('.dw-resize');
-		const grab = el.querySelector('.tbx-sheet-grab');
+		const grab = el.querySelector('.tbx-sheet-resize [data-sheet-grip]'); // ui/SheetGrip since 58db817a
 		const tabs = el.querySelector('.tbx-tabs');
 		return {
 			left: Math.round(r.left),
@@ -834,7 +834,7 @@ h.run(async () => {
 			bottom: Math.round(r.bottom),
 			top: Math.round(r.top),
 			gripHidden: !grip || getComputedStyle(grip).display === 'none',
-			hasGrabber: !!grab && getComputedStyle(grab.parentElement).display !== 'none',
+			hasGrabber: !!grab && grab.offsetHeight > 0,
 			bodyScrolls: getComputedStyle(body).overflowY === 'auto',
 			// tabs must stay OUT of the scrolling area so they are always reachable
 			tabsPinned: !body.contains(tabs)
@@ -851,7 +851,7 @@ h.run(async () => {
 	// the grabber resizes and the height persists
 	const resized = await M.page.evaluate(async () => {
 		const el = document.querySelector('#mesh-edit-popup');
-		const handle = el.querySelector('.tbx-sheet-resize');
+		const handle = el.querySelector('.tbx-sheet-resize [data-sheet-grip]'); // the gesture is sheetDrag on its zone; events bubble to it
 		const before = Math.round(el.getBoundingClientRect().height);
 		const send = (type, y) =>
 			handle.dispatchEvent(new PointerEvent(type, { bubbles: true, pointerId: 7, clientY: y }));
diff --git a/tests/e2e/model-preview.test.cjs b/tests/e2e/model-preview.test.cjs
index 60dd7c587..b23f74de5 100644
--- a/tests/e2e/model-preview.test.cjs
+++ b/tests/e2e/model-preview.test.cjs
@@ -51,12 +51,14 @@ h.run(async () => {
 	await A.page.evaluate(() => window.__stores.enable3dPreview.set(false));
 	await A.page.locator('#explorer-slot').click();
 	await A.page.waitForTimeout(500);
+	// R22 round 12 (cefc68ee): a library OBJECT double-clicks into the file preview window
+	// (#image-preview-window, target kind 'object'); ModelPreviewWindow is the prefab shelf's now
 	await A.page.locator('#explorer-list .explorer-card', { hasText: 'testbox' }).first().dblclick();
-	await A.page.waitForTimeout(900);
-	h.check(
-		(await A.page.locator('#model-preview-window').count()) === 1,
-		'double-click opens the popup even with the toggle off (P1)'
-	);
+	const opened = await A.page
+		.waitForSelector('#image-preview-window', { timeout: 8000 })
+		.then(() => true, () => false);
+	const kind = await A.page.evaluate(() => new Promise((r) => window.__stores.fileWindows.imagePreviewTarget.subscribe((t) => r(t?.kind ?? null))()));
+	h.check(opened && kind === 'object', `double-click opens the preview even with the toggle off (P1) (window ${opened}, kind ${kind})`);
 
 	await h.finish(browser);
 });
diff --git a/tests/e2e/net-drop.test.cjs b/tests/e2e/net-drop.test.cjs
new file mode 100644
index 000000000..591015327
--- /dev/null
+++ b/tests/e2e/net-drop.test.cjs
@@ -0,0 +1,261 @@
+// test-health-1 (plans review #29, done/b5-network-stress.md's device smoke): A 5 s CONNECTION DROP
+// MUST NOT TEAR A TWO-PEER SESSION DOWN — no "disconnected" toast, the peer stays in the roster with
+// its locks, and what was edited during the drop arrives afterwards.
+//
+// What a real wifi drop does to a Chromium tab, and how each part is reproduced headless (tc netem
+// needs root and would hit every lane on this box):
+//  * the signaling WebSocket dies (ERR_NETWORK_CHANGED) and nothing new can be fetched until the
+//    network is back — `context.setOffline(true)` on both pages, and the socket closed by hand
+//    (offline emulation leaves an OPEN socket alone);
+//  * the data channels go silent — a page shim HOLDS every message it would deliver and releases
+//    them in order when the drop ends (SCTP retransmits what it buffered once the path is back);
+//  * ICE reports `disconnected` after its consent checks fail, and `connected` again after —
+//    the shim reports both on every RTCPeerConnection.
+// Two shapes, both DROP_MS long (default 5000):
+//  1. QUIET: all of the above. The same conn should simply carry on.
+//  2. HARD (a network CHANGE): the same, plus the peer connection is closed outright at the start, so
+//     the B5 reconnect window has to redial — through a signaling server it cannot reach until the
+//     drop ends. The window is ~15.5 s (checks at 0.5/1/2/4/8 s), so a 5 s drop must fit inside it.
+// Counterfactual: NETDROP_MS=20000 outlasts the window — phase 2 goes red (teardown + toast; measured
+// e2e/v10cf). Phase 1 stays green at 20 s, by design: a QUIET drop never breaks the data channel, so it
+// proves the conn carries on, not the window's length.
+const h = require('./helpers.cjs');
+
+const DROP_MS = Number(process.env.NETDROP_MS || 5000);
+
+/** runs in the page before any app code: the hold switch + fake ICE state */
+function dropShim() {
+	const D = (window.__drop = { holding: false, queue: /** @type {Function[]} */ ([]), pcs: /** @type {RTCPeerConnection[]} */ ([]), held: 0 });
+	const wrap = (/** @type {Function} */ fn) =>
+		function (/** @type {any} */ event) {
+			// @ts-ignore
+			const self = this;
+			if (D.holding) {
+				D.held++;
+				D.queue.push(() => fn.call(self, event));
+				return;
+			}
+			return fn.call(self, event);
+		};
+	const proto = RTCDataChannel.prototype;
+	const desc = /** @type {PropertyDescriptor} */ (Object.getOwnPropertyDescriptor(proto, 'onmessage'));
+	Object.defineProperty(proto, 'onmessage', {
+		configurable: true,
+		get() {
+			return this.__onmsg ?? null;
+		},
+		set(fn) {
+			this.__onmsg = fn;
+			desc.set?.call(this, typeof fn === 'function' ? wrap(fn) : fn);
+		}
+	});
+	const add = proto.addEventListener;
+	proto.addEventListener = function (/** @type {string} */ type, /** @type {any} */ fn, /** @type {any} */ opts) {
+		return add.call(this, type, type === 'message' && typeof fn === 'function' ? wrap(fn) : fn, opts);
+	};
+	// the signaling server stays unreachable for the whole drop: offline emulation alone let peerjs's
+	// own reconnect back in mid-drop (A was on the server again at 2.8 s), so a socket opened while
+	// the drop holds goes nowhere
+	const RealWS = window.WebSocket;
+	// @ts-ignore
+	window.WebSocket = function (/** @type {string} */ url, /** @type {any} */ protocols) {
+		return new RealWS(D.holding ? 'wss://127.0.0.1:9/' : url, protocols);
+	};
+	window.WebSocket.prototype = RealWS.prototype;
+	Object.setPrototypeOf(window.WebSocket, RealWS);
+	const Real = window.RTCPeerConnection;
+	// @ts-ignore
+	window.RTCPeerConnection = function (/** @type {any[]} */ ...args) {
+		const pc = new Real(...args);
+		D.pcs.push(pc);
+		return pc;
+	};
+	window.RTCPeerConnection.prototype = Real.prototype;
+	Object.setPrototypeOf(window.RTCPeerConnection, Real);
+	/** @param {'disconnected' | null} state null = the real one again */
+	// @ts-ignore
+	D.ice = (state) => {
+		for (const pc of D.pcs) {
+			if (pc.signalingState === 'closed') continue;
+			if (state) Object.defineProperty(pc, 'iceConnectionState', { configurable: true, get: () => state });
+			// @ts-ignore
+			else delete pc.iceConnectionState;
+			pc.dispatchEvent(new Event('iceconnectionstatechange'));
+			// @ts-ignore
+			pc.oniceconnectionstatechange?.(new Event('iceconnectionstatechange'));
+		}
+	};
+	// @ts-ignore
+	D.release = () => {
+		D.holding = false;
+		for (const run of D.queue.splice(0)) {
+			try {
+				run();
+			} catch (e) {
+				setTimeout(() => {
+					throw e;
+				});
+			}
+		}
+	};
+}
+
+h.run(async () => {
+	const browser = await h.launch();
+	const A = await h.setupPage(browser, 'A', { init: dropShim });
+	const B = await h.setupPage(browser, 'B', { init: dropShim });
+	await h.connect(B, A);
+
+	const store = (/** @type {any} */ p, /** @type {string} */ name) =>
+		p.page.evaluate((/** @type {string} */ n) => new Promise((r) => window.__stores[n].subscribe((/** @type {any} */ v) => r(v))()), name);
+	const inRoster = async (/** @type {any} */ p, /** @type {string} */ id) => (await store(p, 'userdata')).some((/** @type {any} */ u) => u[0] === id);
+	const openTo = (/** @type {any} */ p, /** @type {string} */ id) =>
+		p.page.evaluate((/** @type {string} */ pid) => {
+			/** @type {any} */ let pc;
+			window.__stores.peers.subscribe((/** @type {any} */ v) => (pc = v))();
+			return !!pc.connections[pid]?.open && pc.openedPeers.has(pid);
+		}, id);
+	const create = (/** @type {any} */ p, /** @type {string} */ shape) =>
+		p.page.evaluate((/** @type {string} */ s) => {
+			window.__stores.commandsHandler.sceneCommand('/create ' + s);
+			/** @type {any} */ let g;
+			window.__stores.objectsGroup.subscribe((/** @type {any} */ v) => (g = v))();
+			return g.children[g.children.length - 1].uuid;
+		}, shape);
+	const has = (/** @type {any} */ p, /** @type {string} */ uuid) =>
+		p.page.evaluate((/** @type {string} */ u) => {
+			/** @type {any} */ let g;
+			window.__stores.objectsGroup.subscribe((/** @type {any} */ v) => (g = v))();
+			return !!g?.getObjectByProperty('uuid', u);
+		}, uuid);
+	const disconnectToasts = async (/** @type {any} */ p, /** @type {number} */ from) =>
+		(await store(p, 'notifications')).slice(from).filter((/** @type {any} */ n) => /disconnected/.test(String(n.text))).length;
+	const signalingUp = (/** @type {any} */ p) =>
+		p.page.evaluate(() => {
+			/** @type {any} */ let pc;
+			window.__stores.peers.subscribe((/** @type {any} */ v) => (pc = v))();
+			return !!pc.peer && !pc.peer.disconnected && pc.peer.open !== false;
+		});
+
+	await h.eventually(() => openTo(A, B.id), (v) => v, 'premise: A holds an open conn to B');
+	await h.eventually(() => openTo(B, A.id), (v) => v, 'premise: B holds an open conn to A');
+	// a created object is selected = locked by its creator; B always holds one from here on (each
+	// create moves it), and a teardown releases every lock of the departed peer
+	const bLocks = async () => (await store(A, 'lockedObjects')).filter((/** @type {any} */ x) => x[0] === B.id).length;
+	const lockBox = await create(B, 'box');
+	await h.eventually(() => store(A, 'lockedObjects'), (l) => l.some((/** @type {any} */ x) => x[0] === B.id && x[1] === lockBox), "premise: A sees B's lock");
+
+	/** @param {'quiet' | 'hard'} shape */
+	async function drop(shape) {
+		const tag = shape.toUpperCase() + ` ${DROP_MS / 1000}s drop:`;
+		const toastsA = (await store(A, 'notifications')).length;
+		const toastsB = (await store(B, 'notifications')).length;
+		// mark the conns, to tell "the same conn carried on" from "a redial healed it"
+		for (const [p, other] of [[A, B.id], [B, A.id]]) {
+			await p.page.evaluate((/** @type {string} */ id) => {
+				/** @type {any} */ let pc;
+				window.__stores.peers.subscribe((/** @type {any} */ v) => (pc = v))();
+				pc.connections[id].__th1 = 'before';
+			}, other);
+		}
+		// ---- the network goes away
+		for (const p of [A, B]) await p.page.context().setOffline(true);
+		for (const p of [A, B]) {
+			await p.page.evaluate(() => {
+				/** @type {any} */ let pc;
+				window.__stores.peers.subscribe((/** @type {any} */ v) => (pc = v))();
+				// @ts-ignore
+				window.__drop.holding = true;
+				// @ts-ignore
+				window.__drop.ice('disconnected');
+				try {
+					pc.peer._socket._socket?.close();
+				} catch {}
+			});
+		}
+		// the premise is read AT THE CUT: whether peerjs's own reconnect later slips past the shim (it did,
+		// now and then) is the app recovering, not the drop failing to happen
+		let cut = false;
+		for (const t = Date.now(); !cut && Date.now() - t < 3000; await A.page.waitForTimeout(150))
+			cut = !(await signalingUp(A)) && !(await signalingUp(B)); // peerjs marks itself down on the socket's close event
+		if (shape === 'hard') {
+			await A.page.evaluate((/** @type {string} */ id) => {
+				/** @type {any} */ let pc;
+				window.__stores.peers.subscribe((/** @type {any} */ v) => (pc = v))();
+				pc.connections[id].peerConnection?.close();
+			}, B.id);
+		}
+		const t0 = Date.now();
+		/** @type {string[]} */
+		const lost = [];
+		/** what each side's reconnect window is doing, printed if the heal fails @type {string[]} */
+		const timeline = [];
+		const state = (/** @type {any} */ p, /** @type {string} */ id) =>
+			p.page
+				.evaluate((/** @type {string} */ pid) => {
+					/** @type {any} */ let pc;
+					window.__stores.peers.subscribe((/** @type {any} */ v) => (pc = v))();
+					const c = pc.connections[pid];
+					const age = (/** @type {any} */ x) => (x?.__dialedAt ? Math.round((Date.now() - x.__dialedAt) / 100) / 10 + 's' : '-');
+					return `sig=${pc.peer?.open ? 1 : 0} rec=${pc.reconnecting.get(pid) ?? '-'} conn=${c ? (c.open ? 'open' : 'neg ' + age(c)) : 'none'} in=${pc.inboundDials?.has(pid) ? 'neg ' + age(pc.inboundDials.get(pid)) : '-'} opened=${pc.openedPeers.has(pid) ? 1 : 0}`;
+				}, id)
+				.catch((/** @type {any} */ e) => 'err ' + String(e?.message ?? e).slice(0, 60));
+		const watch = async () => {
+			timeline.push(`${((Date.now() - t0) / 1000).toFixed(1)}s A[${await state(A, B.id)}] B[${await state(B, A.id)}]`);
+			if (!(await inRoster(A, B.id))) lost.push(`A lost B at ${Date.now() - t0}ms`);
+			if (!(await inRoster(B, A.id))) lost.push(`B lost A at ${Date.now() - t0}ms`);
+			if ((await bLocks()) === 0) lost.push(`A dropped B's lock at ${Date.now() - t0}ms`);
+		};
+		// an edit on each side DURING the drop
+		await A.page.waitForTimeout(Math.min(1500, DROP_MS / 3));
+		const duringA = await create(A, 'sphere');
+		const duringB = await create(B, 'cylinder');
+		while (Date.now() - t0 < DROP_MS) {
+			await watch();
+			await A.page.waitForTimeout(500);
+		}
+		h.check(cut, `${tag} premise: the signaling link really was down on both pages (at the cut)`);
+		// ---- the network comes back: lift the shim's hold FIRST, so the app's own `online` retry
+		// (fired by setOffline(false)) reaches the real server rather than the held-down socket
+		for (const p of [A, B]) {
+			await p.page.evaluate(() => {
+				// @ts-ignore
+				window.__drop.ice(null);
+				// @ts-ignore
+				window.__drop.release();
+			});
+		}
+		for (const p of [A, B]) await p.page.context().setOffline(false);
+		// watch the roster through the rest of the reconnect window: ~15.5 s from the drop's start, plus
+		// the up-to-20 s its last check gives a dial still negotiating (VERDICT_GRACE_MS)
+		const healed = { a: false, b: false };
+		while (Date.now() - t0 < Math.max(DROP_MS, 0) + 37000) {
+			await watch();
+			healed.a ||= await openTo(A, B.id);
+			healed.b ||= await openTo(B, A.id);
+			if (healed.a && healed.b && Date.now() - t0 > 16000) break;
+			await A.page.waitForTimeout(500);
+		}
+		h.check(lost.length === 0, `${tag} each peer kept the other in its roster, and B's lock stood, throughout (${lost.slice(0, 2).join(', ') || 'never lost'})`);
+		const healedBoth = (await openTo(A, B.id)) && (await openTo(B, A.id));
+		if (!healedBoth) console.log(`  ${tag} timeline (A=${A.id} B=${B.id}; the lower id dials):\n    ` + timeline.join('\n    '));
+		h.check(healedBoth, `${tag} the conn is open both ways again`);
+		h.check((await disconnectToasts(A, toastsA)) === 0 && (await disconnectToasts(B, toastsB)) === 0, `${tag} no "disconnected" toast on either side`);
+		await h.eventually(() => has(B, duringA), (v) => v, `${tag} A's edit made during the drop reaches B`, 15000);
+		await h.eventually(() => has(A, duringB), (v) => v, `${tag} B's edit made during the drop reaches A`, 15000);
+		const afterB = await create(B, 'cone');
+		await h.eventually(() => has(A, afterB), (v) => v, `${tag} an edit after the drop replicates`, 10000);
+		await h.eventually(async () => (await signalingUp(A)) && (await signalingUp(B)), (v) => v, `${tag} both pages are back on the signaling server`, 20000);
+		const same = await A.page.evaluate((/** @type {string} */ id) => {
+			/** @type {any} */ let pc;
+			window.__stores.peers.subscribe((/** @type {any} */ v) => (pc = v))();
+			return pc.connections[id]?.__th1 === 'before';
+		}, B.id);
+		if (shape === 'quiet') h.check(same, `${tag} the SAME conn carried on (no redial was needed)`);
+		else h.check(!same, `${tag} premise: the conn really was replaced by the reconnect window`);
+	}
+
+	await drop('quiet');
+	await drop('hard');
+	await h.finish(browser);
+});
diff --git a/tests/e2e/net-reconnect.test.cjs b/tests/e2e/net-reconnect.test.cjs
index 6781f1c99..72be9ba87 100644
--- a/tests/e2e/net-reconnect.test.cjs
+++ b/tests/e2e/net-reconnect.test.cjs
@@ -1,7 +1,8 @@
 // B5 / phase-172 deferred item 1: transient drops heal instead of tearing down.
 //
 // An OPEN conn dropping without a goodbye now gets a bounded redial window
-// (500/1000/2000/4000ms, netBackoff) before any teardown: the peer's roster
+// (checks at 0.5/1.5/3.5/7.5/15.5 s, netBackoff; the last waits out a dial still
+// negotiating, up to DIAL_GRACE_MS) before any teardown: the peer's roster
 // entry, avatar and locks survive a wifi wobble, and no "disconnected" toast
 // fires unless they are really gone. Announced leaves (leaveSession broadcasts
 // the existing `disconnected` message about itself; pagehide does the same
@@ -31,7 +32,8 @@ h.run(async () => {
 			return !!pc.connections[pid]?.open && pc.openedPeers.has(pid);
 		}, id);
 
-	await h.eventually(() => openTo(C, B.id), (v) => v, 'mesh formed: C holds an open conn to B');
+	// a mesh-fill dial negotiates like any other: ~6-12 s on a loaded box, past eventually's 10 s default
+	await h.eventually(() => openTo(C, B.id), (v) => v, 'mesh formed: C holds an open conn to B', 26000);
 
 	// --- a relayed 'disconnected' about a live peer is ignored
 	await C.page.evaluate(([aid, bid]) => {
@@ -69,14 +71,18 @@ h.run(async () => {
 		(await store(A, 'lockedObjects')).some((x) => x[0] === B.id && x[1] === uuid),
 		"B's lock survives the blip"
 	);
-	await h.eventually(() => openTo(A, B.id), (v) => v, 'the conn to B is re-opened by the backoff', 12000);
+	// bounded by the product's own window (15.5 s + a negotiating dial's 10 s grace): a 12 s wait was
+	// shorter than the window it tests, and a redial measured 6-9 s to open on a loaded box
+	await h.eventually(() => openTo(A, B.id), (v) => v, 'the conn to B is re-opened by the backoff', 26000);
 	const notifs = await store(A, 'notifications');
 	h.check(
 		!notifs.slice(notifCountBefore).some((n) => String(n.text).includes('disconnected')),
 		'no disconnect toast fired for a drop that healed'
 	);
 
-	// messages flow again after the heal
+	// messages flow again after the heal — from B, so B's own side must be healed too (A's open conn
+	// is the check above; B adopts the redial, or dials it, on its own schedule)
+	await h.eventually(() => openTo(B, A.id), (v) => v, "(premise) B's side of the conn is open again", 26000);
 	await B.page.evaluate(() => window.__stores.commandsHandler.sceneCommand('/create sphere'));
 	const countOn = (p) =>
 		p.page.evaluate(() => {
@@ -85,7 +91,30 @@ h.run(async () => {
 			return g?.children?.length ?? 0;
 		});
 	const bCount = await countOn(B);
-	await h.eventually(() => countOn(A), (c) => c >= bCount, "B's new object reaches A after the heal", 10000);
+	let reached = false;
+	await h.eventually(() => countOn(A), (c) => (reached = c >= bCount), "B's new object reaches A after the heal", 10000);
+	// both links are open by now, so a red here is past the transport: say whether a share-or-stash ask
+	// (gateHolds — it drops a peer's room content while open) or a connect decision is holding it
+	if (!reached)
+		for (const [name, p, other] of [['A', A, B], ['B', B, A]])
+			console.log(
+				`  ${name} after the heal: ` +
+					JSON.stringify(
+						await p.page.evaluate((o) => {
+							const s = window.__stores;
+							let decision = null;
+							let notes = [];
+							s.connectionState?.pendingConnectDecision?.subscribe?.((v) => (decision = v))?.();
+							s.notifications?.subscribe?.((v) => (notes = v))?.();
+							return {
+								gateHolds: s.sessions?.gateHolds?.(o) ?? null,
+								decision: decision ? Object.keys(decision) : null,
+								objects: (() => { let g; s.objectsGroup.subscribe((v) => (g = v))(); return g?.children?.map((c) => c.name); })(),
+								lastToasts: notes.slice(-3).map((n) => String(n.text).slice(0, 90))
+							};
+						}, other.id)
+					)
+			);
 
 	// --- announced leave tears down promptly, with no redial spam
 	const t0 = Date.now();
diff --git a/tests/e2e/panels.test.cjs b/tests/e2e/panels.test.cjs
index 40e51f876..626d14b42 100644
--- a/tests/e2e/panels.test.cjs
+++ b/tests/e2e/panels.test.cjs
@@ -57,10 +57,14 @@ h.run(async () => {
 	h.check(await A.page.getByText('Objects', { exact: false }).first().isVisible(), 'object list header visible');
 	h.check(await A.page.locator('#object-search').isVisible(), 'search survived the restyle');
 
-	// save dropdown format picker still opens
-	await A.page.getByRole('button', { name: /json/i }).first().click();
-	await A.page.waitForTimeout(300);
-	h.check(await A.page.getByText('GLTF', { exact: true }).isVisible(), 'save format dropdown opens');
+	// the save format picker still opens — Save options (the burger's Save ▾) since 41b replaced the
+	// old .json dropdown; GLTF is behind "Offer GLTF", so assert the two formats it always offers
+	await A.page.evaluate(() => window.__stores.closeMenu.set(false));
+	await A.page.waitForSelector('#save-options-open', { timeout: 5000 });
+	await A.page.locator('#save-options-open').click();
+	await A.page.waitForSelector('#save-options-modal', { state: 'visible', timeout: 5000 });
+	const formats = await A.page.evaluate(() => [...document.querySelectorAll('#save-format .seg-opt')].map((b) => b.textContent?.trim()));
+	h.check(formats.includes('Project') && formats.includes('Scene'), `save format picker opens (${JSON.stringify(formats)})`);
 
 	await h.finish(browser);
 });
diff --git a/tests/e2e/physics-discoverability.test.cjs b/tests/e2e/physics-discoverability.test.cjs
index 58405c423..06e4564a0 100644
--- a/tests/e2e/physics-discoverability.test.cjs
+++ b/tests/e2e/physics-discoverability.test.cjs
@@ -29,6 +29,8 @@ h.run(async () => {
 		b1.name = 'PropsBox';
 		b2.name = 'FlowBox';
 		b3.name = 'BareBox';
+		// /create makes every box dynamic since 95df3a66 — this suite needs them bare to start with
+		for (const b of [b1, b2, b3]) delete b.userData.physics;
 		// spread them out — overlapping colliders would explode the fallback sim
 		b1.position.set(0, 0.5, 0);
 		b2.position.set(3, 0.5, 0);
diff --git a/tests/e2e/physics-kinematic.test.cjs b/tests/e2e/physics-kinematic.test.cjs
index 2c3c2eb4b..be6884a7d 100644
--- a/tests/e2e/physics-kinematic.test.cjs
+++ b/tests/e2e/physics-kinematic.test.cjs
@@ -51,6 +51,9 @@ h.run(async () => {
 		const group = await new Promise((r) => window.__stores.objectsGroup.subscribe(r)());
 		const [slab, box] = group.children.slice(-2);
 		slab.position.set(0, 1, 0);
+		// /create makes every primitive dynamic since 95df3a66 — the slab must be scenery, so the spin
+		// effect is what makes it a KINEMATIC platform (a dynamic slab just falls to the ground)
+		delete slab.userData.physics;
 		box.position.set(2, 1.75, 0); // resting on the slab top, 2m off-axis
 		// dynamic via Inspector-style userData.physics (NO flow mass node)
 		box.userData.physics = { mode: 'dynamic', mass: 1 };
@@ -58,6 +61,7 @@ h.run(async () => {
 		peer.send({ type: 'move', uuid: slab.uuid, pos: [0, 1, 0], rot: [0, 0, 0], scale: [1, 1, 1] });
 		peer.send({ type: 'move', uuid: box.uuid, pos: [2, 1.75, 0], rot: [0, 0, 0], scale: [1, 1, 1] });
 		peer.send({ type: 'objectParameters', parameter: 'physics', uuid: box.uuid, physics: box.userData.physics });
+		peer.send({ type: 'objectParameters', parameter: 'physics', uuid: slab.uuid, physics: null });
 		// spin effect on the slab -> it becomes a KINEMATIC platform mid-sim
 		const nodes = [
 			{ id: 'sp1', type: 'spin', position: { x: 0, y: 0 }, data: { type: 'spin', axis: 'y', speed: 2 }, class: 'w-[150px]' },
diff --git a/tests/e2e/play-reentry.test.cjs b/tests/e2e/play-reentry.test.cjs
index 7995c2cec..df6893586 100644
--- a/tests/e2e/play-reentry.test.cjs
+++ b/tests/e2e/play-reentry.test.cjs
@@ -245,7 +245,8 @@ h.run(async () => {
 			return Promise.reject(new Error('refused'));
 		};
 		window.__stores.isLocked.set(true);
-		await new Promise((r) => setTimeout(r, 400));
+		// until the retry has really run once (bounded) — a fixed 400 ms saw 0 attempts under load
+		for (const t0 = Date.now(); calls < 1 && Date.now() - t0 < 3000; ) await new Promise((r) => setTimeout(r, 50));
 		const during = calls;
 		window.__stores.isLocked.set(false);
 		await new Promise((r) => setTimeout(r, 900));
@@ -321,12 +322,40 @@ h.run(async () => {
 	);
 	h.check(onCanvas === 'CANVAS', `premise: that pixel is the canvas, not chrome (${onCanvas})`);
 
+	// test-health-1: record what the right-click reaches — red since 1.41 with no product change in
+	// this path found, so a red says WHICH guard ate it (no event / a slow pair past the 400 ms tap
+	// limit / a blocking store)
+	await X.evaluate(() => {
+		const w = /** @type {any} */ (window);
+		w.__rc = [];
+		const name = (/** @type {any} */ el) => (el ? el.tagName + (el.id ? '#' + el.id : '') + (typeof el.className === 'string' && el.className ? '.' + el.className.trim().split(/\s+/).slice(0, 3).join('.') : '') : null);
+		for (const t of ['pointerdown', 'contextmenu'])
+			window.addEventListener(t, (e) => w.__rc.push([t, name(e.target), name(/** @type {any} */ (e.target)?.parentElement), /** @type {any} */ (e).button, Date.now()]), true);
+	});
+	await X.evaluate((p) => (/** @type {any} */ (window).__rcAt = p), at);
 	await X.mouse.click(at.x, at.y, { button: 'right' });
+	let menuOpened = false;
 	await h.eventually(
 		() => X.evaluate(() => document.querySelectorAll('[role="menuitem"]').length),
-		(n) => n > 0,
+		(n) => (menuOpened = n > 0),
 		'right-click opens the viewport context menu after a denied session'
 	);
+	if (!menuOpened)
+		console.log(
+			'  right-click reached: ' +
+				JSON.stringify(
+					await X.evaluate(() => {
+						const s = window.__stores;
+						const g = (/** @type {string} */ k) => {
+							let v;
+							s[k]?.subscribe?.((/** @type {any} */ x) => (v = x))?.();
+							return v;
+						};
+						const el = document.elementFromPoint(/** @type {any} */ (window).__rcAt?.x ?? 0, /** @type {any} */ (window).__rcAt?.y ?? 0);
+						return { rc: /** @type {any} */ (window).__rc, underNow: el ? el.tagName + '#' + el.id + '.' + String(el.className).slice(0, 60) : null, ...Object.fromEntries(['isLocked', 'isVRMode', 'specatorMode', 'drawMode', 'editingObject', 'measureMode'].map((k) => [k, g(k)])) };
+					})
+				)
+		);
 	await X.keyboard.press('Escape');
 	await X.waitForTimeout(200);
 
diff --git a/tests/e2e/post-play-mode.test.cjs b/tests/e2e/post-play-mode.test.cjs
index fcd1c2f7b..89721cd26 100644
--- a/tests/e2e/post-play-mode.test.cjs
+++ b/tests/e2e/post-play-mode.test.cjs
@@ -100,7 +100,12 @@ h.run(async () => {
 			(delta.changed ?? -1) +
 			' changed pixels)'
 	);
-	const off = await h.framePixelsOffColor(page, after, FILL_RGB);
+	// colour is measured on a CHROME-FREE region (helpers.grabFrame's rule): play mode composites
+	// the glass bar (PlayBanner, 930ecc44) and the reticle over the canvas, and the full frame read a
+	// constant 20780 px "off the fill" — left of centre, clear of the bar, the HUD and the reticle
+	const view = await page.viewportSize();
+	const fillClip = { x: Math.round(view.width * 0.1), y: Math.round(view.height * 0.35), width: Math.round(view.width * 0.25), height: Math.round(view.height * 0.3) };
+	const off = await h.framePixelsOffColor(page, await h.grabFrame(A, fillClip), FILL_RGB);
 	h.check(
 		off.fraction < 0.02,
 		'2.2 ...and it is the effect that painted it (' +
@@ -177,7 +182,7 @@ h.run(async () => {
 	// and putting the look back brings the composer back
 	await page.evaluate(() => window.__stores.scenePost.addPostEffect('test-play-fill'));
 	await page.waitForTimeout(1200);
-	const restored = await h.grabFrame(A);
+	const restored = await h.grabFrame(A, fillClip);
 	const restoredOff = await h.framePixelsOffColor(page, restored, FILL_RGB);
 	h.check(
 		restoredOff.fraction < 0.02,
diff --git a/tests/e2e/quarantine.json b/tests/e2e/quarantine.json
new file mode 100644
index 000000000..9749685cf
--- /dev/null
+++ b/tests/e2e/quarantine.json
@@ -0,0 +1,49 @@
+{
+	"comment": "test-health-1 — e2e checks that run but do not gate (scripts/ci/quarantine.cjs; the battery reports them in their own tier). perf/budgets.json \"allow\" one domain over: suite + optionally ONE check (a substring of its FAIL label; absent = the whole suite), why, who owns the fix, since, review. A suite red is non-blocking only when EVERY failed check matches an entry (a crash or timeout never is, unless the whole suite is listed). Past-review and now-green entries print as warnings. Remove an entry in the PR that fixes it.",
+	"quarantine": [
+		{"suite": "sessions", "check": "accepted load replaced the scene on both peers", "reason": "UNRESOLVED, possibly a product bug: after Accept the proposer's load never completes — v5b: a live, uncancelled 'SceneOne' job, both links open, nothing cleared (stuck before applySessionNow's replicated clear: the only awaits there are the 'Backup before' saveSession, the library restore and the physics import — idb.js can leave a promise pending forever); v3b: A cleared and added nothing, B applied nothing. Hidden behind the e3edaee5 strict-mode crash since 2026-10-21, so no passing run exists to bisect; needs a run tracing sessions.js (test-health-1 2026-10-24)", "owner": "test-health (standing lane)", "since": "2026-10-24", "review": "2026-11-07"},
+		{"suite": "lock-ux", "check": "B renders a lock highlight box", "reason": "load-sensitive: the Approve toast click is intercepted by the canvas and the toast detaches; green in a quiet slot (75 s vs 131-136 s red), red on v1.42.0 in the same place (57-union, 65-union)", "owner": "test-health (standing lane)", "since": "2026-10-24", "review": "2026-11-07"},
+		{"suite": "ui-fixes-15lmno", "check": "incoming toasts never shift it", "reason": "the toast burst moves the spectator 8 px under load (a fixed sleep); a different row red each run, pristine v1.41.0 3/3 red (50-int r4)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "ui-fixes-15lmno", "check": "the Roughness readout shows the material", "reason": "read before the Inspector re-renders under load (fixed sleep); red on pristine v1.41.0 (50-int r4)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "ui-fixes-15lmno", "check": "it hides after the grace period", "reason": "fixed-sleep grace window vs load (50-int r3)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "checkpoints", "check": "after Accept the peer has the checkpoint", "reason": "two-peer timing; red on the union AND pristine v1.41.0, green in r4 (50-int, 50-window)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "checkpoints", "check": "and so does the host", "reason": "flips run to run with the row above (green r1, red r3; 50-int)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "checkpoints", "check": "an autosave write cuts an automatic row", "reason": "the automatic row lands ~15.7 s, the check waits 12 s (50-window)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "scene-load", "check": "1.4 no long task over", "reason": "a 204-389 ms long task vs the 200 ms line under load; known in 39/40/41/42 incl. A/B bases (L3)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "scene-load", "check": "6.3 no long task over", "reason": "as 1.4, while restoring; the one L3 row red on preview-1-42 (50-int)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "scene-load", "check": "4.4 a toast says the load was stopped", "reason": "the toast is read after it expired under load (49-int x1, 50-int)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "net-handshake", "check": "C received the scene", "reason": "third peer handshake timing; red on pristine v1.41.0 and on 904599c1 (50-int r3, 55-invite)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "flow-physics-actions", "check": "2.1 mode 'continuous' KEEPS pushing", "reason": "body at 0 m/s under a held key on a slow frame; flaky in every app x driver cell (deps-1 ab3)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "flow-physics-actions", "check": "4.3 read 'speed' reports real motion", "reason": "as 2.1 (deps-1 ab3)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "flow-physics-actions", "check": "8.5 and the very NEXT press throws the box", "reason": "stale-press guard vs frame timing (pcA, deps-1)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "select-41", "check": "G4 (near) a finger on the crate takes it", "reason": "G4 flick timing: 12/12 green on --local, red under load (deps-1 ab3)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "select-41", "check": "G14 (unfolded) a tap selects", "reason": "the unfolded N6 page under load: a tap is a click only if its pointerdown->pointerup handlers run within 400 ms of page time, and a long software-GL frame between them voids it — red in 3 of 4 runs, a different first check each time (base, v3b, v5a; green v4b). The other race in this block (the finger landing on the seated gizmo: axis XYZ, dragging true at pointerup, e2e/v4b) is fixed in Scene.svelte", "owner": "test-health (standing lane)", "since": "2026-10-24", "review": "2026-11-07"},
+		{"suite": "select-41", "check": "G14 (unfolded) a tap on the selected box deselects it", "reason": "a finger tap on the box lands on the seated gizmo (captured in the capture phase at pointerup: axis XYZ, dragging true) and the box stays selected — red in after-battery and v3b, green in v4b. A fix keyed on that state did NOT change it (reverted): Scene's window pointerup runs after TransformControls' own, so it never sees that state. Product race not understood; owner", "owner": "test-health (standing lane)", "since": "2026-10-25", "review": "2026-11-07"},
+		{"suite": "select-41", "check": "G13 (unfolded) Interact deselects", "reason": "the unfolded N6 page under load: a tap is a click only if its pointerdown->pointerup handlers run within 400 ms of page time, and a long software-GL frame between them voids it — red in 3 of 4 runs, a different first check each time (base, v3b, v5a; green v4b). The other race in this block (the finger landing on the seated gizmo: axis XYZ, dragging true at pointerup, e2e/v4b) is fixed in Scene.svelte", "owner": "test-health (standing lane)", "since": "2026-10-24", "review": "2026-11-07"},
+		{"suite": "select-41", "check": "G13 (unfolded) and Edit restores", "reason": "the unfolded N6 page under load: a tap is a click only if its pointerdown->pointerup handlers run within 400 ms of page time, and a long software-GL frame between them voids it — red in 3 of 4 runs, a different first check each time (base, v3b, v5a; green v4b). The other race in this block (the finger landing on the seated gizmo: axis XYZ, dragging true at pointerup, e2e/v4b) is fixed in Scene.svelte", "owner": "test-health (standing lane)", "since": "2026-10-24", "review": "2026-11-07"},
+		{"suite": "avatar-feet", "check": "1.3 standing: B's lowest sole is on the floor", "reason": "red 2/4 d3d12, 3/3 llvmpipe, green on rerun (mux-pc-host)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "avatar-feet", "check": "1.7 the body origin stays on the floor while walking", "reason": "software GL: a 12 cm rise at the start of the walk that settles over ~400 ms (origin y per stride 12.2 3.0 0.7 0.7 0.2 0.2 0.0 0.0 cm, e2e/v4b) — not sinking, and the feet are on the wire every stride since the localFeet staleness fix; green on the GPU PC (pcbat). Source of the 12 cm not found", "owner": "test-health (standing lane)", "since": "2026-10-24", "review": "2026-11-07"},
+		{"suite": "aquarium-reef", "check": "2.1 every fallback group built its PACK model", "reason": "1 red in 3 on each GPU path: pack fetch vs the wait (mux-pc-host)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "aquarium-reef", "check": "2.2 every group DRAWS a pack level", "reason": "as 2.1 (mux-pc-host)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "pack-behavior", "check": "7.2 OPEN: the capsule walks through the doorway", "reason": "a fixed 300 ms wait vs charController's lazy physics import; base 1/3 red (59-replace)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "code-workspace", "check": "Save as file binds the node", "reason": "a 2000 ms wait; flaked on both base and lane (50-yjs, 50-window)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "animation-node", "check": "so the door closes rather than restarting", "reason": "~1.7 fps under load: a 900 ms window holds 1-2 frames; 35/0 on a GPU slot (57-clips)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "dock-strip-drop", "check": "6.3 opening an Explorer image brings the docked editor forward", "reason": "red 1/2 on both 1.41 and 1.40 production, green on base in deps-1 ab1 (53-int)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "toolbar-slots-42", "check": "I9: each corner shows ONE", "reason": "known deployed flake (touch reorder, unfolded dark); same 2 reds on production 1.39 (49-int, 53-int)", "owner": "test-health (standing lane)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "context-menu-redesign", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "edit-move-games", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "fb-water", "check": "a foam body floats high", "reason": "software GL (~4 fps): rapier keeps real time only down to 7.5 fps (8 substeps of 1/60 s per frame), so the hull lags waves that follow the session clock — green needs a GPU slot; the test cannot fix the frame rate (test-health-1, e2e/v2)", "owner": "test-health (standing lane)", "since": "2026-10-24", "review": "2026-11-07"},
+		{"suite": "fb-water", "check": "...is never swamped", "reason": "software GL (~4 fps): rapier keeps real time only down to 7.5 fps (8 substeps of 1/60 s per frame), so the hull lags waves that follow the session clock — green needs a GPU slot; the test cannot fix the frame rate (test-health-1, e2e/v2)", "owner": "test-health (standing lane)", "since": "2026-10-24", "review": "2026-11-07"},
+		{"suite": "fb-water", "check": "...upright", "reason": "software GL (~4 fps): rapier keeps real time only down to 7.5 fps (8 substeps of 1/60 s per frame), so the hull lags waves that follow the session clock — green needs a GPU slot; the test cannot fix the frame rate (test-health-1, e2e/v2)", "owner": "test-health (standing lane)", "since": "2026-10-24", "review": "2026-11-07"},
+		{"suite": "fb-water", "check": "underwater: aligned", "reason": "flips run to run (green on the base, 68.9 vs 37.4 px in e2e/v2): outline vs object read 1 s after a water-quality switch, while the shaders recompile at ~4 fps", "owner": "test-health (standing lane)", "since": "2026-10-24", "review": "2026-11-07"},
+		{"suite": "kit-instancing", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "net-stress", "check": "premise: every peer ran well above the 20/s gate", "reason": "section 5 is a RATE claim against display frames and needs a GPU (its own comment): four pages on software GL orbit at 1 fps, so the 20/s gate cannot be exercised (e2e/v4a; sections 1-4 and the freeze check green)", "owner": "test-health (standing lane)", "since": "2026-10-24", "review": "2026-11-07"},
+		{"suite": "net-stress", "check": "premise: the camera stream flows between every pair while orbiting", "reason": "section 5 is a RATE claim against display frames and needs a GPU (its own comment): four pages on software GL orbit at 1 fps, so the 20/s gate cannot be exercised (e2e/v4a; sections 1-4 and the freeze check green)", "owner": "test-health (standing lane)", "since": "2026-10-24", "review": "2026-11-07"},
+		{"suite": "net-stress", "check": "presence is gated, not per frame", "reason": "section 5 is a RATE claim against display frames and needs a GPU (its own comment): four pages on software GL orbit at 1 fps, so the 20/s gate cannot be exercised (e2e/v4a; sections 1-4 and the freeze check green)", "owner": "test-health (standing lane)", "since": "2026-10-24", "review": "2026-11-07"},
+		{"suite": "phone-sheets", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "timeline-export", "reason": "NOT a flake — ENV: the exporter reads build/export-manifest.json, which a dev server has none of, so on the dev-server battery it can only fail (CI skips it in battery.json for the same reason). Green 9/9 against a production build served by scripts/serve-build.cjs (test-health-1, e2e/tlx, 2026-10-24). Run it there: npm run build && node scripts/serve-build.cjs --port <p>, APP_URL at that port", "owner": "test-health (standing lane)", "since": "2026-10-24", "review": "2026-11-07"},
+		{"suite": "touch-actions", "reason": "carried red since 1.41, red on the unchanged base too (deps-1 A/B on 1f3b9dd5, 2026-10-23) — moved from battery.json \"optional\"", "owner": "test-health-1 (phase 2: fix the test, fix the code, or delete with a reason)", "since": "2026-10-23", "review": "2026-11-07"},
+		{"suite": "water-migration", "check": "pool-party (saved on 1.22) looks the same", "reason": "looks the same by eye (golden vs today, e2e/migration/*-now.png, test-health-1 2026-10-24); the measured change is a global tone shift (mean sum-of-channels delta 3.8-9.3, identical run to run with autoQuality pinned) plus the pool rim band — render changes since the goldens (bd143435). OWNER DECISION: re-baseline the goldens on today's build (drops the 'rendered by 1.22' provenance) or a perceptual metric; NOT a threshold raise", "owner": "test-health (standing lane) + owner decision", "since": "2026-10-24", "review": "2026-11-07"},
+		{"suite": "water-migration", "check": "island-ocean (saved on 1.22) looks the same", "reason": "looks the same by eye (golden vs today, e2e/migration/*-now.png, test-health-1 2026-10-24); the measured change is a global tone shift (mean sum-of-channels delta 3.8-9.3, identical run to run with autoQuality pinned) plus the pool rim band — render changes since the goldens (bd143435). OWNER DECISION: re-baseline the goldens on today's build (drops the 'rendered by 1.22' provenance) or a perceptual metric; NOT a threshold raise", "owner": "test-health (standing lane) + owner decision", "since": "2026-10-24", "review": "2026-11-07"}
+	]
+}
diff --git a/tests/e2e/reload-memory.test.cjs b/tests/e2e/reload-memory.test.cjs
new file mode 100644
index 000000000..6deeb6836
--- /dev/null
+++ b/tests/e2e/reload-memory.test.cjs
@@ -0,0 +1,109 @@
+// test-health-1 (plans review #24, roadmap-42 Follow-ups): RELOADING ONE TAB MUST NOT GROW IT.
+//
+// The report: editor-ui-33 died on its 5th reload in one tab (WebGL context lost / Target crashed)
+// and the heap grew ~29 MB per reload. A reload replaces the document, so anything that grows
+// ACROSS reloads is something the old document left behind: the old document itself (a reference
+// from something that outlives it), or GPU memory the old page's WebGL contexts still held.
+//
+// Per reload, after a forced GC: the JS heap, the number of live Documents (1 = only the current
+// one; more = an old document is retained), and the resident memory of this browser's renderer and
+// GPU processes (ps, so it sees what Chromium's own heap metrics do not: WebGL buffers live in the
+// GPU process). Evidence: EVIDENCE/reload-memory.json.
+const fs = require('fs');
+const path = require('path');
+const h = require('./helpers.cjs');
+
+const RELOADS = Number(process.env.RELOADS || 6);
+const SETTLE_MS = Number(process.env.RELOAD_SETTLE_MS || 4000);
+const EVIDENCE = process.env.EVIDENCE || path.join(process.env.HOME || '.', '.code/lanes-30/after-60/60-test-health-1');
+// thresholds: the growth that killed a tab was ~29 MB/reload of JS heap; a steady state after the
+// first reload (caches warm) should be flat within noise
+const MAX_HEAP_MB_PER_RELOAD = Number(process.env.MAX_HEAP_MB_PER_RELOAD || 5);
+const MAX_GPU_MB_PER_RELOAD = Number(process.env.MAX_GPU_MB_PER_RELOAD || 25);
+
+/** RSS (MB) of the renderer + gpu processes of this browser, by type, from Chromium's own process
+ * list (SystemInfo.getProcessInfo — Playwright's Browser has no process(), only a BrowserServer
+ * does, so the first version never measured these). /proc is local only: on a remote slot the
+ * browser runs elsewhere and this answers null. @param {any} bcdp */
+async function processRss(bcdp) {
+	try {
+		const { processInfo } = await bcdp.send('SystemInfo.getProcessInfo');
+		const rss = (/** @type {number} */ pid) => {
+			const m = /VmRSS:\s+(\d+) kB/.exec(fs.readFileSync(`/proc/${pid}/status`, 'utf8'));
+			return m ? +m[1] / 1024 : 0;
+		};
+		const sum = (/** @type {string} */ type) => Math.round(processInfo.filter((/** @type {any} */ p) => p.type === type).reduce((t, /** @type {any} */ p) => t + rss(p.id), 0));
+		return { renderer: sum('renderer'), gpu: sum('GPU') };
+	} catch {
+		return { renderer: null, gpu: null };
+	}
+}
+
+h.run(async () => {
+	const browser = await h.launch();
+	const bcdp = await browser.newBrowserCDPSession();
+	const A = await h.setupPage(browser, 'A');
+	// Runtime.getHeapUsage + Memory.getDOMCounters are read FRESH per call; the first version read
+	// Performance.getMetrics, which on a reloaded target kept answering the first document's
+	// numbers (seven byte-identical rows), so it could not see growth at all
+	const cdp = await A.page.context().newCDPSession(A.page);
+	await cdp.send('HeapProfiler.enable');
+	const sample = async (/** @type {number} */ i) => {
+		await A.page.waitForTimeout(SETTLE_MS);
+		await cdp.send('HeapProfiler.collectGarbage');
+		await cdp.send('HeapProfiler.collectGarbage');
+		const heap = await cdp.send('Runtime.getHeapUsage');
+		const dom = await cdp.send('Memory.getDOMCounters');
+		const gl = await A.page.evaluate(() => {
+			/** @type {any} */ let r;
+			window.__stores.globalRenderer.subscribe((/** @type {any} */ v) => (r = v))();
+			return r?.info?.memory ?? null;
+		}).catch(() => null);
+		// the premise: every sample is a FRESH document (an unchanged timeOrigin = no reload happened)
+		const origin = await A.page.evaluate(() => performance.timeOrigin);
+		return {
+			reload: i,
+			origin,
+			heapMB: Math.round((heap.usedSize / 1048576) * 10) / 10,
+			documents: dom.documents,
+			nodes: dom.nodes,
+			listeners: dom.jsEventListeners,
+			gl,
+			...(await processRss(bcdp))
+		};
+	};
+	/** @type {any[]} */
+	const rows = [await sample(0)];
+	console.log(JSON.stringify(rows[0]));
+	let crashed = '';
+	for (let i = 1; i <= RELOADS; i++) {
+		try {
+			await h.freshReload(A);
+			await h.answerRestore(A).catch(() => false);
+		} catch (error) {
+			crashed = `reload ${i}: ${String(/** @type {any} */ (error)?.message ?? error).split('\n')[0]}`;
+			break;
+		}
+		rows.push(await sample(i));
+		console.log(JSON.stringify(rows[rows.length - 1]));
+	}
+	fs.mkdirSync(EVIDENCE, { recursive: true });
+	fs.writeFileSync(path.join(EVIDENCE, 'reload-memory.json'), JSON.stringify({ at: new Date().toISOString(), url: h.URL, rows, crashed }, null, 1));
+
+	h.check(!crashed, `the tab survives ${RELOADS} reloads (${crashed || 'all of them'})`);
+	h.check(new Set(rows.map((r) => r.origin)).size === rows.length, `premise: each sample is a fresh document (${new Set(rows.map((r) => r.origin)).size} distinct of ${rows.length})`);
+	// growth from the FIRST reload on: reload 0 -> 1 warms caches every app has
+	const from = rows[1] ?? rows[0];
+	const last = rows[rows.length - 1];
+	const n = Math.max(1, last.reload - from.reload);
+	const heapPer = (last.heapMB - from.heapMB) / n;
+	h.check(heapPer <= MAX_HEAP_MB_PER_RELOAD, `JS heap after GC grows <= ${MAX_HEAP_MB_PER_RELOAD} MB per reload (${heapPer.toFixed(1)} MB/reload: ${rows.map((r) => r.heapMB).join(' → ')})`);
+	// an absolute count says little (the page legitimately owns more than one: iframes, an inert
+	// template document); a RETAINED old document shows up as the count climbing reload by reload
+	h.check(last.documents <= from.documents, `no old document is retained (live Documents per reload: ${rows.map((r) => r.documents).join(', ')})`);
+	if (last.gpu != null && from.gpu != null) {
+		const gpuPer = (last.gpu - from.gpu) / n;
+		h.check(gpuPer <= MAX_GPU_MB_PER_RELOAD, `GPU process RSS grows <= ${MAX_GPU_MB_PER_RELOAD} MB per reload (${gpuPer.toFixed(1)} MB/reload: ${rows.map((r) => r.gpu).join(' → ')})`);
+	}
+	await h.finish(browser);
+});
diff --git a/tests/e2e/scene-budget.test.cjs b/tests/e2e/scene-budget.test.cjs
index 2e0f7a916..cca527506 100644
--- a/tests/e2e/scene-budget.test.cjs
+++ b/tests/e2e/scene-budget.test.cjs
@@ -88,9 +88,21 @@ h.run(async () => {
 	h.check(typeof live.ingestBacklog === 'number', 'a registered source (the ingest backlog) reaches the sample');
 
 	// ---- 3. the meter's dot moves with the scene ----------------------------
-	await A.page.waitForTimeout(700);
-	const greenDot = await A.page.getAttribute('#object-budget-dot', 'data-tier');
-	h.check(greenDot === 'green', `24 objects reads green in the status line (${greenDot})`);
+	// the dot is the WORST tier of every budget (Controls worstTier), so on software GL (~3 fps) frame
+	// time alone turns it red whatever the scene holds. Judge the OBJECTS row, and the dot only when the
+	// frame rows leave it to the objects.
+	const tierOf = (/** @type {string} */ key) =>
+		A.page.evaluate((k) => {
+			const b = window.__stores.sceneBudget;
+			let m;
+			b.sceneMetrics.subscribe((v) => (m = v))();
+			return b.budgetRows(m, m?.profile ?? 'desktop').find((r) => r.key === k)?.tier ?? null;
+		}, key);
+	await h.eventually(() => tierOf('objects'), (t) => t === 'green', '24 objects reads green on the objects budget');
+	if ((await tierOf('frameP95')) === 'green') {
+		const greenDot = await A.page.getAttribute('#object-budget-dot', 'data-tier');
+		h.check(greenDot === 'green', `…and in the status line (${greenDot})`);
+	} else console.log('  (frame time is over budget on this renderer — the status-line dot is not the objects reading here)');
 
 	await A.page.evaluate(async () => {
 		const { THREE, objectsGroup, pokeScene } = window.__stores;
@@ -101,15 +113,18 @@ h.run(async () => {
 		for (let i = 0; i < 3200; i++) group.add(new THREE.Mesh(geo, mat));
 		pokeScene();
 	});
+	await h.eventually(() => tierOf('objects'), (t) => t === 'red', 'the objects budget goes RED past the ceiling');
 	await h.eventually(
 		() => A.page.getAttribute('#object-budget-dot', 'data-tier'),
 		(t) => t === 'red',
 		'the status-line dot goes RED when the object budget is exceeded'
 	);
-	const title = await A.page.getAttribute('#object-count', 'title');
-	h.check(
-		/over on/.test(String(title)) && /object/i.test(String(title)),
-		`…and the tooltip names WHAT is over budget (${title})`
+	// the tooltip follows the NEXT sample (the 3200 objects), not the moment the dot went red — read it
+	// once it says so, instead of the instant after a dot that frame time had already turned red
+	await h.eventually(
+		() => A.page.getAttribute('#object-count', 'title'),
+		(t) => /over on/.test(String(t)) && /object/i.test(String(t)),
+		'…and the tooltip names WHAT is over budget'
 	);
 
 	// ---- 4. the panel, through its real entry point --------------------------
diff --git a/tests/e2e/scene-post-effects.test.cjs b/tests/e2e/scene-post-effects.test.cjs
index fc0c4f700..ae5c1513e 100644
--- a/tests/e2e/scene-post-effects.test.cjs
+++ b/tests/e2e/scene-post-effects.test.cjs
@@ -248,7 +248,13 @@ h.run(async () => {
 			let original = null;
 			peers.subscribe((p) => (original = p))();
 			const sent = [];
-			peers.set({ ...original, send: (m) => sent.push(m) });
+			// assetShare sends per OPEN CONNECTION since 9c81d069 (chunked transfers + the ledger), not
+			// through peers.send — and nobody has joined yet in this section, so give it one to send on
+			peers.set({
+				...original,
+				send: (m) => sent.push(m),
+				connections: { ...(original.connections ?? {}), spy: { open: true, send: (m) => sent.push(m) } }
+			});
 			document.querySelector('#post-param-' + id + '-lut').click();
 			await new Promise((r) => setTimeout(r, 300));
 			const rows = [...document.querySelectorAll('.ts-list [role="option"]')];
diff --git a/tests/e2e/scene-post.test.cjs b/tests/e2e/scene-post.test.cjs
index ea5d6b432..cb30918e6 100644
--- a/tests/e2e/scene-post.test.cjs
+++ b/tests/e2e/scene-post.test.cjs
@@ -1005,7 +1005,9 @@ h.run(async () => {
 	// one-switch escape hatch if their driver cannot cope. `(pointer: coarse)` is
 	// emulable with a hasTouch context (unlike the mobile VIEWPORT, which needs
 	// isMobile too).
-	const T = await h.setupPage(browser, 'Touch', { context: { hasTouch: true } });
+	// the quality governor drops AO on slow frames (qualityOverrides.aoOff filters it out of the stack),
+	// and software GL is slow on every page — pin it, or 9.12 measures the governor, not the touch rule
+	const T = await h.setupPage(browser, 'Touch', { context: { hasTouch: true }, storage: { autoQuality: 'false' } });
 	const touch = await T.page.evaluate(async () => {
 		window.__stores.viewMode.set('shaded');
 		window.__stores.scenePost.scenePostRestore({
@@ -1013,20 +1015,30 @@ h.run(async () => {
 			effects: [{ id: 'a', kind: 'ao' }],
 			changedAt: 99
 		});
-		await new Promise((r) => setTimeout(r, 1400));
-		const on = window.__postDebug();
+		// the stack stays empty until the composer has warmed (postWarm, >10 rendered frames —
+		// 0.6-2.5 s at 4-17 fps), the same wait section 3.2 makes; a fixed 1400 ms read it cold
+		const t0 = performance.now();
+		let on = window.__postDebug();
+		while (!(on.postWarm && on.kinds.includes('ao')) && performance.now() - t0 < 20000) {
+			await new Promise((r) => requestAnimationFrame(r));
+			on = window.__postDebug();
+		}
 		window.__stores.viewportOverrides.setRenderLayer('post', false);
 		await new Promise((r) => setTimeout(r, 900));
+		let mode = null;
+		window.__stores.viewMode.subscribe((v) => (mode = v))();
 		return {
 			coarse: window.__stores.inputDevice.coarsePointer(),
 			kinds: on.kinds,
+			// what the composer said, so a red names its reason (warm-up, a skip, an empty plan, the mode)
+			why: { postWarm: on.postWarm, postOk: on.postOk, skipped: on.skipped, plan: (on.plan ?? []).length, stackPasses: on.stackPasses, mode, auto: localStorage.getItem('autoQuality') },
 			afterOff: window.__postDebug().stackPasses
 		};
 	});
 	h.check(touch.coarse === true, '9.11 premise: the touch context really reports a coarse pointer');
 	h.check(
 		touch.kinds.includes('ao'),
-		'9.12 a touch device renders the scene look too — no silent second class of viewer'
+		'9.12 a touch device renders the scene look too — no silent second class of viewer (' + JSON.stringify(touch.kinds) + ' ' + JSON.stringify(touch.why) + ')'
 	);
 	h.check(touch.afterOff === 0, '9.12b ...and the same one-switch escape hatch works there');
 
diff --git a/tests/e2e/script-guard.test.cjs b/tests/e2e/script-guard.test.cjs
index 9041ae925..41c66d818 100644
--- a/tests/e2e/script-guard.test.cjs
+++ b/tests/e2e/script-guard.test.cjs
@@ -94,23 +94,26 @@ h.run(async () => {
 	h.check(clicked !== null, 'and the real UI is still there to be driven');
 
 	// the frame loop kept going: rAF still fires
+	const FRAME_WINDOW_MS = 3000;
 	const frames = await A.page.evaluate(
-		() =>
+		(FRAME_WINDOW_MS) =>
 			new Promise((resolve) => {
 				let n = 0;
 				const t0 = performance.now();
 				const step = () => {
 					n++;
-					if (performance.now() - t0 > 1800) return resolve(n);
+					if (performance.now() - t0 > FRAME_WINDOW_MS) return resolve(n);
 					requestAnimationFrame(step);
 				};
 				requestAnimationFrame(step);
-			})
+			}),
+		FRAME_WINDOW_MS
 	);
 	// 1800 ms, not 600: headless SwiftShader runs ~5 fps and the runaway costs part of every frame, so 600 ms
 	// was 2-4 frames on either side of the threshold (1.24.0 and 1.25 both measure 9 frames / 2 s — 36-int-125);
-	// a frozen loop reads 0-1
-	h.check(frames > 3, `the render loop is still running (${frames} frames in 1800ms)`);
+	// a frozen loop reads 0-1. test-health-1: 3000 ms and >= 3 — a GitHub runner measured exactly 3 in 1800 ms
+	// (ci.yml e2e-smoke, 2026-10-23/24), red at `> 3` with the loop plainly alive.
+	h.check(frames >= 3, `the render loop is still running (${frames} frames in ${FRAME_WINDOW_MS}ms)`);
 
 	// ---- 3. a healthy node beside it still works ---------------------------------------
 	const uuid2 = await makeBox(A);
@@ -135,8 +138,10 @@ h.run(async () => {
 	// script at a million iterations, so it cannot buy time by looping MORE, it has to do
 	// more work per iteration. 900k plain additions measured about a millisecond here and
 	// the check failed for the fixture's sake rather than the feature's.
+	// (the counter on window is test-health-1's: when the badge never comes, it tells "the node did
+	// not run" from "it ran and was never paused")
 	const SLOW_SRC =
-		'let s = 0; for (let i = 0; i < 500000; i++) { s += Math.sin(i) * Math.cos(i); } data.s = s;';
+		'let s = 0; for (let i = 0; i < 500000; i++) { s += Math.sin(i) * Math.cos(i); } data.s = s; globalThis.__slowRuns = (globalThis.__slowRuns || 0) + 1;';
 	const bodyMs = await A.page.evaluate((src) => {
 		const fn = new Function('data', src);
 		const t0 = performance.now();
@@ -153,13 +158,32 @@ h.run(async () => {
 			() => {
 				let v = {};
 				window.__stores.scriptErrors.subscribe((m) => (v = m))();
-				return /too slow/i.test(String(v['slow'] ?? '')) ? v['slow'] : false;
+				if (/too slow/i.test(String(v['slow'] ?? ''))) return v['slow'];
+				// 40 runs and still no badge is a real red (a run under 8 ms resets the streak, so not 31)
+				return /** @type {any} */ (globalThis).__slowRuns >= 40 ? 'NO BADGE' : false;
 			},
-			{ timeout: 30000 }
+			// the guard pauses on the 30th slow RUN in a row (SLOW_FRAMES), so the wait counts runs: a time
+			// estimate from the measured frame rate ended at exactly 29 runs twice on a GitHub runner (this
+			// node slows the frames it is measured by). Badge, or the node has run well past 30 — bounded.
+			{ timeout: 180000 }
 		)
 		.then((r) => r.jsonValue())
 		.catch(() => null);
-	h.check(!!slowBadge, `a slow node is paused rather than left to eat the frame (${slowBadge})`);
+	const badged = !!slowBadge && slowBadge !== 'NO BADGE';
+	const slowWhy = badged
+		? slowBadge
+		: JSON.stringify(
+				await A.page
+					.evaluate(() => {
+						/** @type {any} */ let errs = {};
+						/** @type {any} */ let paused = null;
+						window.__stores.scriptErrors.subscribe((/** @type {any} */ m) => (errs = m))();
+						window.__stores.flowPaused.subscribe((/** @type {any} */ p) => (paused = p))();
+						return { runs: /** @type {any} */ (globalThis).__slowRuns ?? 0, errs, paused, visible: document.visibilityState };
+					})
+					.catch((/** @type {any} */ e) => String(e))
+			);
+	h.check(badged, `a slow node is paused rather than left to eat the frame (${slowWhy})`);
 	h.check(
 		await A.page.evaluate(() => 1 + 1).then((v) => v === 2),
 		'and the page is still responsive after it'
diff --git a/tests/e2e/search-menus.test.cjs b/tests/e2e/search-menus.test.cjs
index 0379f9ef7..b85201f98 100644
--- a/tests/e2e/search-menus.test.cjs
+++ b/tests/e2e/search-menus.test.cjs
@@ -79,21 +79,18 @@ h.run(async () => {
 	h.check((await page.locator('#add-search-input').inputValue()) === '', 'Clear empties the field');
 	await page.keyboard.press('Escape');
 
-	// node search: open flow, right-click pane, type to search, box right-drags
+	// node search: open flow, right-click pane, type to search. Since 26537bb6 the search runs inside
+	// the pane's context menu (its filter row), so the old pop-up box — and its right-drag — are gone
 	await page.locator('p[title="Node editor (N)"]').click();
 	await page.waitForTimeout(600);
 	await page.locator('.svelte-flow__pane').click({ button: 'right', position: { x: 400, y: 120 } });
-	await page.waitForTimeout(300);
+	await page.waitForSelector('.ctx-filter', { state: 'attached', timeout: 5000 });
 	await page.keyboard.type('s');
-	await page.waitForTimeout(300);
-	h.check(await page.locator('#node-search-box').isVisible(), 'node search opens');
-	const nb = await page.locator('#node-search-box').boundingBox();
-	await page.mouse.move(nb.x + 60, nb.y + 70);
-	await page.mouse.down({ button: 'right' });
-	await page.mouse.move(nb.x + 180, nb.y + 140, { steps: 5 });
-	await page.mouse.up({ button: 'right' });
-	const nbAfter = await page.locator('#node-search-box').boundingBox();
-	h.check(nbAfter.x > nb.x + 80, `node search box right-drags (${nb.x} → ${nbAfter.x})`);
+	const opened = await page
+		.waitForSelector('.ctx-filter.on', { timeout: 5000 })
+		.then(() => true, () => false);
+	h.check(opened, 'node search opens (the menu filter row)');
+	h.check((await page.locator('.ctx-match').count()) > 0, 'typing lists matching nodes');
 
 	await ctx.close();
 	await h.finish(browser);
diff --git a/tests/e2e/select-41.test.cjs b/tests/e2e/select-41.test.cjs
index bd49b7e91..28f2a8827 100644
--- a/tests/e2e/select-41.test.cjs
+++ b/tests/e2e/select-41.test.cjs
@@ -329,8 +329,10 @@ h.run(async () => {
 		const t0 = await screenOf(P, uuid, dx, dy);
 		const cam0 = (await store(P, 'globalCamera')) ? await P.evaluate(() => { let c; window.__stores.globalCamera.subscribe((v) => (c = v))(); return c.position.toArray(); }) : null;
 		await touch.send('touchStart', t0.x, t0.y);
-		await P.waitForTimeout(250);
-		const taken = await P.evaluate(() => window.__stores.playInteract.playInteractDebug().carrying);
+		// wait for the grab instead of a fixed 250 ms (a frame or two on software GL); the move starts
+		// from a carry that exists, and a carry that never comes still reads as not taken
+		const taken = await P.waitForFunction((u) => window.__stores.playInteract.playInteractDebug().carrying === u, uuid, { timeout: 3000 })
+			.then(() => uuid, () => P.evaluate(() => window.__stores.playInteract.playInteractDebug().carrying));
 		const t1 = await screenOf(P, uuid);
 		const grip0 = t0.local ? await screenOfLocal(P, uuid, t0.local) : null;
 		for (let i = 1; i <= steps; i++) {
@@ -402,7 +404,14 @@ h.run(async () => {
 	h.check(c.hit && c.taken, 'G4 (far) the finger takes the crate 10 m away');
 	h.check(c.jump < 8 && Math.abs(dist1 - dist0) < 0.6, `G4 (far) it stays at its distance (${dist0.toFixed(2)} -> ${dist1.toFixed(2)} m, jump ${c.jump.toFixed(1)} px)`);
 	h.check(c.track < 14, `G4 (far) and follows the finger (off by ${c.track.toFixed(1)} px)`);
-	await P.waitForTimeout(1500);
+	// the flick aims at where the crate IS: wait for the far carry's release to come to rest (a fixed
+	// 1.5 s left a light crate still sliding at ~4 fps, so the finger landed beside it)
+	await h.eventually(
+		() => P.evaluate((u) => window.__stores.physics.bodyVelocityOf(u), crate),
+		(v) => !!v && Math.hypot(...v.linvel) < 0.05,
+		'(premise) the crate is at rest before the flick',
+		15000
+	);
 
 	// a FLICK: released mid-move, the throw is bounded
 	const crateAt2 = (await screenOf(P, crate)).pos;
@@ -419,6 +428,11 @@ h.run(async () => {
 	const U = await h.setupPage(browser, 'unfolded', { context: N6_UNFOLDED, storage: STORAGE });
 	const Q = U.page;
 	const touchU = await touchApi(Q);
+	// a tap within 400 ms of the last one is a DOUBLE-tap (Scene.svelte), which does not deselect — on the
+	// PAGE's clock. A long software-GL frame makes 700 ms of test time less than that in the app, so each
+	// tap below waits until the page itself is 450 ms past the last pointerup
+	await Q.evaluate(() => window.addEventListener('pointerup', () => (window.__lastUp = Date.now()), true));
+	const pastDoubleTap = () => Q.waitForFunction(() => Date.now() - (window.__lastUp ?? 0) > 450);
 	await look(Q, [0, 3, 6], [0, 0.5, 0]);
 	const ua = await make(Q, [-1.2, 0.5, 0]);
 	await rest(Q);
@@ -427,9 +441,24 @@ h.run(async () => {
 	await touchU.tap(at.x, at.y);
 	await Q.waitForTimeout(700);
 	h.check(JSON.stringify(await sel(Q)) === JSON.stringify([ua]), 'G14 (unfolded) a tap selects');
+	await pastDoubleTap();
+	// what the finger lands on: the folded run passes with the same code, and on this larger screen the
+	// seated gizmo may cover the box — a red says whether the tap reached a gizmo handle (axis/dragging)
+	await Q.evaluate(() => {
+		const w = /** @type {any} */ (window);
+		w.__gz = [];
+		const note = (/** @type {string} */ t) => {
+			let tc;
+			w.__stores.TControls?.subscribe?.((/** @type {any} */ v) => (tc = v))?.();
+			w.__gz.push([t, tc?.axis ?? null, !!tc?.dragging]);
+		};
+		for (const t of ['pointerdown', 'pointerup']) window.addEventListener(t, () => note(t), { capture: true, once: true });
+	});
 	await touchU.tap(at.x, at.y);
 	await Q.waitForTimeout(700);
-	h.check((await sel(Q)).length === 0, `G14 (unfolded) a tap on the selected box deselects it (${JSON.stringify(await sel(Q))})`);
+	const gizmo = await Q.evaluate(() => /** @type {any} */ (window).__gz);
+	h.check((await sel(Q)).length === 0, `G14 (unfolded) a tap on the selected box deselects it (${JSON.stringify(await sel(Q))}; gizmo at the tap ${JSON.stringify(gizmo)})`);
+	await pastDoubleTap();
 	await touchU.tap(at.x, at.y);
 	await Q.waitForTimeout(700);
 	const modeCell = '#editor-mode-toggle';
diff --git a/tests/e2e/sessions.test.cjs b/tests/e2e/sessions.test.cjs
index 97c2302ab..0bba9ae95 100644
--- a/tests/e2e/sessions.test.cjs
+++ b/tests/e2e/sessions.test.cjs
@@ -77,30 +77,57 @@ h.run(async () => {
 	await A.page.evaluate((id) => window.__stores.sessions.requestLoadSession(id), target.id);
 	await B.page.waitForTimeout(800);
 	h.check(
-		await B.page.getByText(/wants to load session/).isVisible(),
+		// the TOAST, not its copy in the screen-reader live region (e3edaee5) — getByText matched both
+		await B.page.locator('.tp-toast-text', { hasText: /wants to load session/ }).isVisible(),
 		'B sees the proposal toast'
 	);
-	await B.page.getByRole('button', { name: 'Decline', exact: true }).click();
+	// the proposal's OWN toast's button: another toast's action could share the name
+	await B.page.locator('.tp-toast', { hasText: /wants to load session/ }).getByRole('button', { name: 'Decline', exact: true }).click();
 	await A.page.waitForTimeout(800);
 	h.check(
-		await A.page.getByText(/declined the session load/).isVisible(),
+		await A.page.locator('.tp-toast-text', { hasText: /declined the session load/ }).isVisible(),
 		'A is told about the decline'
 	);
 
 	// then B accepts: the load applies and replicates
 	await A.page.evaluate((id) => window.__stores.sessions.requestLoadSession(id), target.id);
 	await B.page.waitForTimeout(800);
-	await B.page.getByRole('button', { name: 'Accept', exact: true }).click();
+	await B.page.locator('.tp-toast', { hasText: /wants to load session/ }).getByRole('button', { name: 'Accept', exact: true }).click();
+	let replaced = false;
 	await h.eventually(
 		() => Promise.all([objectNames(A.page), objectNames(B.page)]),
 		([a, b]) =>
-			a.filter((n) => n === 'Box').length === 1 &&
-			a.includes('Sphere') &&
-			b.filter((n) => n === 'Box').length === 1 &&
-			b.includes('Sphere'),
+			(replaced =
+				a.filter((n) => n === 'Box').length === 1 &&
+				a.includes('Sphere') &&
+				b.filter((n) => n === 'Box').length === 1 &&
+				b.includes('Sphere')),
 		'accepted load replaced the scene on both peers',
 		15000
 	);
+	// test-health-1: red since the toast check stopped masking it (e3edaee5) and not explained from the
+	// code (A clears and adds nothing, B applies nothing) — a red prints each side's link, load job and
+	// recent net/session diagnostics, so the next run says which path stopped
+	if (!replaced)
+		for (const [name, p, other] of [['A', A, B], ['B', B, A]])
+			console.log(
+				`  ${name} after Accept: ` +
+					JSON.stringify(
+						await p.page.evaluate((otherId) => {
+							const s = window.__stores;
+							let pc;
+							s.peers.subscribe((v) => (pc = v))();
+							const job = s.sceneLoader.currentJob?.();
+							return {
+								id: pc?.peer?.id,
+								openTo: !!pc?.connections?.[otherId]?.open,
+								reconnecting: pc?.reconnecting?.get?.(otherId) ?? null,
+								job: job ? { name: job.name, cancelled: !!job.cancelled, interrupted: !!job.interrupted } : null,
+								log: (s.diagnostics.lines?.() ?? []).filter((l) => /net|session|load|clear|wire/i.test(JSON.stringify(l))).slice(-12)
+							};
+						}, other.id)
+					)
+			);
 
 	await h.finish(browser);
 });
diff --git a/tests/e2e/settings-layout.test.cjs b/tests/e2e/settings-layout.test.cjs
index 046f9b205..622a77a1e 100644
--- a/tests/e2e/settings-layout.test.cjs
+++ b/tests/e2e/settings-layout.test.cjs
@@ -220,13 +220,15 @@ h.run(async () => {
 		await open(P.page, key);
 		const t = await P.page.evaluate(() => {
 			// a description squeezed beside its control (Density's two long options left it a
-			// one-word column) — on a phone the text keeps at least half the row
+			// one-word column). The floor is the product's own: rowFit keeps a control beside its
+			// label only while the text column keeps TEXT_MIN (150 px, 437423c8) — the old "half the
+			// row" rule contradicted that on a 390 px phone (settings-row-fit asserts the product's)
 			const squeezed = [];
 			for (const row of document.querySelectorAll('#settings-sections .setting-row')) {
 				const el = /** @type {HTMLElement} */ (row);
 				const d = el.querySelector('.sr-desc');
 				if (!el.offsetParent || !d || !(d.textContent || '').trim()) continue;
-				if (d.getBoundingClientRect().width < el.getBoundingClientRect().width * 0.5) squeezed.push((el.querySelector('.sr-name')?.textContent || '').trim());
+				if (d.getBoundingClientRect().width < 149) squeezed.push((el.querySelector('.sr-name')?.textContent || '').trim());
 			}
 			const small = [];
 			for (const el of document.querySelectorAll('#settings-sections .seg-opt, #settings-sections .tp-ui.nr, #settings-sections button.btn, #settings-sections .settings-num, #settings-sections .settings-text')) {
diff --git a/tests/e2e/shader-sync.test.cjs b/tests/e2e/shader-sync.test.cjs
index 572976e52..593959dbb 100644
--- a/tests/e2e/shader-sync.test.cjs
+++ b/tests/e2e/shader-sync.test.cjs
@@ -189,11 +189,36 @@ h.run(async () => {
 		(n) => n === 2,
 		'a LATE JOINER receives the graph through the handshake'
 	);
+	// the compile needs the OBJECT as well as the document (shaderGraph's reconcile retries when it lands):
+	// a red below says which of the two never arrived on the third page
+	await h.eventually(
+		() => C.page.evaluate((u) => new Promise((r) => window.__stores.objectsGroup.subscribe((g) => r(!!g?.getObjectByProperty('uuid', u)))()), uuid),
+		(has) => has === true,
+		'(premise) the late joiner has the cube the graph drives',
+		20000
+	);
+	let cDriven = false;
 	await h.eventually(
 		() => C.page.evaluate((u) => window.__stores.shaderGraph.isShaderDriven(u), uuid),
-		(driven) => driven === true,
+		(driven) => (cDriven = driven === true),
 		'and compiles it locally too'
 	);
+	// a red says WHY: the compile's own errors, and whether a reconcile run by hand compiles it — if it
+	// does, the object arrived without poking objectsGroup and the late-joiner retry never ran
+	if (!cDriven)
+		console.log(
+			'  C compile: ' +
+				JSON.stringify(
+					await C.page.evaluate(async (u) => {
+						const sg = window.__stores.shaderGraph;
+						let errs = null;
+						sg.shaderErrors?.subscribe?.((e) => (errs = e?.[u] ?? null))?.();
+						sg.reconcileShaderGraphs();
+						await new Promise((r) => setTimeout(r, 1500));
+						return { errors: errs, drivenAfterManualReconcile: sg.isShaderDriven(u) };
+					}, uuid)
+				)
+		);
 
 	// ---- 7. delete replicates ----------------------------------------------
 	await A.page.evaluate((u) => window.__stores.shaderGraph.setShaderGraphFor(u, null), uuid);
diff --git a/tests/e2e/sound-node.test.cjs b/tests/e2e/sound-node.test.cjs
index 467e377f8..0c2a4445f 100644
--- a/tests/e2e/sound-node.test.cjs
+++ b/tests/e2e/sound-node.test.cjs
@@ -88,7 +88,9 @@ h.run(async () => {
 			}),
 		hash
 	);
-	h.check(bShared === 'Shared', `pulled bytes land in the Shared folder (${bShared})`);
+	// no stray 'Shared' folder since 186248ba (R22 round 9): pulled bytes take the shared row's folder,
+	// and A imported this one at the library root
+	h.check(bShared === null, `pulled bytes land where the shared row says — the root here, no 'Shared' folder (${bShared})`);
 	await h.eventually(
 		() => entriesOn(B.page),
 		(entries) => entries.length === 1 && entries[0].buffered,
@@ -96,9 +98,11 @@ h.run(async () => {
 	);
 
 	// Play toggles through the REAL node button and replicates as node data
+	// the editor shows the SELECTED object's graph since flow v2 H1 (b2350b75), and /create selected
+	// the box — deselect so it opens on the scene graph that holds the sound node
+	await A.page.evaluate(() => window.__stores.objectActions.deselectObject());
 	await A.page.locator('p[title="Node editor (N)"]').click();
-	await A.page.waitForTimeout(900);
-	await A.page.locator('.node-card button', { hasText: '▶ Play' }).click();
+	await A.page.locator('.node-card button', { hasText: '▶ Play' }).click(); // the locator waits for it
 	await A.page.waitForTimeout(900);
 	aEntries = await entriesOn(A.page);
 	h.check(aEntries[0]?.playing === true, 'Play starts the source on A');
diff --git a/tests/e2e/themes.test.cjs b/tests/e2e/themes.test.cjs
index 28ca4c9eb..fd9b32170 100644
--- a/tests/e2e/themes.test.cjs
+++ b/tests/e2e/themes.test.cjs
@@ -45,7 +45,8 @@ h.run(async () => {
 
 	const dark = await probe('dark');
 	h.check(
-		dark.dataTheme === 'dark' && dark.dark && dark.surface === 'rgb(31, 41, 55)',
+		// tailwind 4's gray-800 (f3c8ef62, tailwind 3.4 -> 4.3); dark mode does not remap .bg-gray-800
+		dark.dataTheme === 'dark' && dark.dark && dark.surface === 'oklch(0.278 0.033 256.848)',
 		`dark is the authored look (surface ${dark.surface})`
 	);
 
diff --git a/tests/e2e/vr-passthrough.test.cjs b/tests/e2e/vr-passthrough.test.cjs
index b938580bd..d5178ee5f 100644
--- a/tests/e2e/vr-passthrough.test.cjs
+++ b/tests/e2e/vr-passthrough.test.cjs
@@ -65,7 +65,15 @@ h.run(async () => {
 				})();
 			})
 	);
-	h.check(restored === '3b4048', `exiting restores the preset sky (#${restored})`);
+	// the preset's OWN background, not a copy of it (c2005ce2 retuned the palette and this went stale)
+	const presetSky = await A.page.evaluate(
+		() =>
+			new Promise((resolve) => {
+				const env = window.__stores.environment;
+				env.environment.subscribe((e) => resolve(String(env.ENVIRONMENT_PRESETS[e?.preset ?? 'studio']?.background ?? '').replace('#', '').toLowerCase()))();
+			})
+	);
+	h.check(restored === presetSky, `exiting restores the preset sky (#${restored}, preset #${presetSky})`);
 	const envAfter = await A.page.evaluate(
 		() =>
 			new Promise((resolve) => {
diff --git a/tests/e2e/water-migration.test.cjs b/tests/e2e/water-migration.test.cjs
index 550124302..60f300197 100644
--- a/tests/e2e/water-migration.test.cjs
+++ b/tests/e2e/water-migration.test.cjs
@@ -23,10 +23,11 @@ const GATED = ['aquarium', 'pool-party', 'island-ocean'];
 const REPORT = ['jelly-room', 'fluid-tank-toy'];
 const T0 = 1791200000000; // a fixed wall clock: the same water phase on every build
 const CLIP = { x: 190, y: 110, width: 900, height: 500 };
+const GOLDEN_CHROME_ROWS = 28;
 
 h.run(async () => {
 	const browser = await h.launch({ args: h.GPU_ARGS });
-	const A = await h.setupPage(browser, 'A', { context: { viewport: { width: 1280, height: 720 } }, storage: { 'water:quality': 'high' } });
+	const A = await h.setupPage(browser, 'A', { context: { viewport: { width: 1280, height: 720 } }, storage: { 'water:quality': 'high', autoQuality: 'false' } }); // test-health-1: the quality governor lowers dpr / shadows / AO on slow frames — a pixel comparison needs it pinned
 	await A.ctx.addInitScript((t) => {
 		Date.now = () => t;
 	}, T0);
@@ -62,7 +63,9 @@ h.run(async () => {
 			h.check(false, `${slug}: no golden (capture with GOLDEN_WRITE=1 on v1.22.0)`);
 			continue;
 		}
-		const d = await h.frameDelta(A.page, fs.readFileSync(goldFile), png, 24);
+		// the 1.22 goldens carry a strip of UI chrome along their top edge (the connect pill was inside
+		// CLIP on that build): compare the scene below it
+		const d = await h.frameDelta(A.page, fs.readFileSync(goldFile), png, 24, GOLDEN_CHROME_ROWS);
 		rows.push(`| ${slug} | ${(d.fraction * 100).toFixed(2)}% | ${d.mean.toFixed(2)} | ${GATED.includes(slug) ? (d.fraction <= MAX_CHANGED ? 'same' : '**DIFFERENT**') : 'reported'} |`);
 		if (GATED.includes(slug))
 			h.check(d.fraction <= MAX_CHANGED, `${slug} (saved on 1.22) looks the same: ${(d.fraction * 100).toFixed(2)}% of the frame changed (max ${(MAX_CHANGED * 100).toFixed(0)}%)`);
diff --git a/tests/unit/quarantine.test.js b/tests/unit/quarantine.test.js
new file mode 100644
index 000000000..66324113f
--- /dev/null
+++ b/tests/unit/quarantine.test.js
@@ -0,0 +1,73 @@
+// test-health-1: the e2e quarantine (scripts/ci/quarantine.cjs) decides which battery reds gate a PR,
+// without a person — so the per-check rule, the crash rule and the file's shape are pinned here.
+import { describe, it, expect } from 'vitest';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const { load, validate, failedChecks, classify, warnings } = require('../../scripts/ci/quarantine.cjs');
+
+const entry = (/** @type {Record<string, string>} */ over = {}) => ({
+	suite: 'ui-fixes',
+	check: 'toast burst',
+	reason: 'a fixed sleep',
+	owner: 'test-health',
+	since: '2026-10-24',
+	review: '2026-11-07',
+	...over
+});
+const q = (/** @type {any[]} */ ...list) => ({ quarantine: list });
+const log = (/** @type {string[]} */ ...lines) => [...lines, lines.some((l) => l.startsWith('FAIL')) ? `${lines.filter((l) => l.startsWith('FAIL')).length} FAILURES` : 'ALL PASS'].join('\n');
+
+describe('quarantine: which reds do not gate', () => {
+	it('reads the FAIL labels helpers.check prints', () => {
+		expect(failedChecks('PASS a\nFAIL the toast burst moved 8 px\n  ✗ two\nnot ok three\n')).toEqual(['the toast burst moved 8 px', 'two', 'three']);
+	});
+	it('a red whose every failed check is quarantined is non-blocking', () => {
+		const v = classify(q(entry()), 'ui-fixes', log('PASS x', 'FAIL the toast burst moved 8 px'));
+		expect(v.quarantined).toBe(true);
+		expect(v.entries).toHaveLength(1);
+	});
+	it('a quarantined row cannot hide a NEW red in the same suite', () => {
+		const v = classify(q(entry()), 'ui-fixes', log('FAIL the toast burst moved 8 px', 'FAIL Roughness row'));
+		expect(v.quarantined).toBe(false);
+		expect(v.unmatched).toEqual(['Roughness row']);
+	});
+	it('a check entry never covers a crash or a timeout', () => {
+		const crash = 'PASS a\nFAIL the toast burst moved 8 px\nSCRIPT FAILED: Timeout 30000ms exceeded';
+		expect(classify(q(entry()), 'ui-fixes', crash).quarantined).toBe(false);
+		expect(classify(q(entry()), 'ui-fixes', 'PASS a\nFAIL the toast burst\n').quarantined).toBe(false); // no verdict line
+		expect(classify(q(entry()), 'ui-fixes', log('FAIL the toast burst'), { timedOut: true }).quarantined).toBe(false);
+	});
+	it('an entry is per suite: the same label in another suite still gates', () => {
+		expect(classify(q(entry()), 'other-suite', log('FAIL the toast burst')).quarantined).toBe(false);
+	});
+	it('a whole-suite entry (no check) covers any red, crash included', () => {
+		const { check, ...whole } = entry();
+		expect(classify(q(whole), 'ui-fixes', 'SCRIPT FAILED: boom').quarantined).toBe(true);
+	});
+});
+
+describe('quarantine.json: the file', () => {
+	it('the committed file validates', () => {
+		expect(validate(load())).toEqual([]);
+	});
+	it('every committed entry names a suite that exists', async () => {
+		const fs = require('node:fs');
+		const path = require('node:path');
+		for (const e of load().quarantine) expect(fs.existsSync(path.resolve('tests/e2e', e.suite + '.test.cjs')), e.suite).toBe(true);
+	});
+	it('refuses a missing field, a bad date, an unknown key and a duplicate', () => {
+		const { owner, ...noOwner } = entry();
+		expect(validate(q(noOwner))).toEqual([expect.stringContaining('.owner is required')]);
+		expect(validate(q(entry({ review: '7 Nov' })))[0]).toContain('review must be YYYY-MM-DD');
+		expect(validate(q(entry({ review: '2026-10-01' })))[0]).toContain('review must be after since');
+		expect(validate(q({ ...entry(), note: 'x' }))[0]).toContain('unknown key note');
+		expect(validate(q(entry(), entry()))[0]).toContain('duplicate');
+	});
+	it('warns (never fails) on a past review date and on a suite that ran green', () => {
+		const w = warnings(q(entry()), [{ name: 'ui-fixes', status: 'pass' }], ['ui-fixes'], '2026-12-01');
+		expect(w.some((x) => x.includes('review date 2026-11-07 has passed'))).toBe(true);
+		expect(w.some((x) => x.includes('ran green'))).toBe(true);
+		expect(warnings(q(entry()), [], ['elsewhere'], '2026-10-25')).toEqual([expect.stringContaining('stale entry')]);
+	});
+});