diff --git a/apps/dashboard/e2e/birth-ritual.spec.ts b/apps/dashboard/e2e/birth-ritual.spec.ts
new file mode 100644
index 0000000..0bfebec
--- /dev/null
+++ b/apps/dashboard/e2e/birth-ritual.spec.ts
@@ -0,0 +1,199 @@
+// ─────────────────────────────────────────────────────────────────────────────
+// v2.3 Birth Ritual — E2E visual proof
+//
+// The Birth Ritual is a 2.3s choreography triggered by MemoryCreated events:
+//   t=0…800ms       gestation (orb pulses in place)
+//   t=800…2300ms    Bezier flight toward graph center
+//   t=2300…2600ms   arrival burst cascade
+//
+// Trigger path in these tests (avoids modifying production code — the
+// websocket store is NOT on window):
+//   1. Navigate to /dashboard/settings
+//   2. Click the "✺ Trigger Birth" button — calls websocket.injectEvent()
+//   3. SPA-route to /dashboard/graph (same tab, same JS context, singleton
+//      store preserves the event in the feed)
+//   4. Graph3D mounts, reads $eventFeed, renders the birth orb.
+//
+// Constraints:
+//   - Graph3D only mounts when the /api/graph call succeeds (loadGraph()).
+//     Without vestige-mcp on 127.0.0.1:3927, the page shows the "Your Mind
+//     Awaits" error panel and NO canvas. Those tests guard on canvas
+//     presence and fixme themselves if the backend isn't reachable — they
+//     don't fail the suite.
+//   - The v2.3-era regression FATAL 6 (multiple simultaneous births crashing
+//     the effect manager) manifested as console errors, so we instrument
+//     pageerror + console listeners and assert zero errors.
+// ─────────────────────────────────────────────────────────────────────────────
+
+import { test, expect, type Page, type ConsoleMessage } from '@playwright/test';
+
+const SETTINGS_URL = '/dashboard/settings';
+const GRAPH_URL = '/dashboard/graph';
+const TRIGGER_BIRTH_TEXT = /Trigger Birth/i;
+
+// Helpers ────────────────────────────────────────────────────────────────────
+
+interface ErrorCapture {
+	pageErrors: Error[];
+	consoleErrors: string[];
+}
+
+function captureErrors(page: Page): ErrorCapture {
+	const capture: ErrorCapture = { pageErrors: [], consoleErrors: [] };
+	page.on('pageerror', (err) => { capture.pageErrors.push(err); });
+	page.on('console', (msg: ConsoleMessage) => {
+		if (msg.type() === 'error') {
+			const text = msg.text();
+			// Filter known-noisy WebSocket/connection errors that appear when
+			// vestige-mcp isn't running — those are infrastructure, not birth
+			// ritual regressions.
+			if (
+				text.includes('WebSocket') ||
+				text.includes('Failed to fetch') ||
+				text.includes('ERR_CONNECTION') ||
+				text.includes('net::') ||
+				text.includes('api/graph') ||
+				text.includes('api/health') ||
+				text.includes('api/stats')
+			) return;
+			capture.consoleErrors.push(text);
+		}
+	});
+	return capture;
+}
+
+async function isGraphMounted(page: Page): Promise<boolean> {
+	// The graph page shows either the loading spinner, an error panel, or
+	// the <Graph3D> component (which mounts a <canvas>). If no canvas
+	// appears within 8s we assume the backend is unreachable.
+	try {
+		await page.waitForSelector('canvas', { timeout: 8000, state: 'attached' });
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+async function injectBirthViaSettings(page: Page) {
+	// SPA-route to /settings first so the websocket module stays resident.
+	// The store is a module-level singleton — navigating through SvelteKit's
+	// client router preserves its state across routes within the same tab.
+	if (!page.url().includes('/settings')) {
+		await page.goto(SETTINGS_URL);
+	}
+	await expect(page.getByRole('button', { name: TRIGGER_BIRTH_TEXT })).toBeVisible();
+	await page.getByRole('button', { name: TRIGGER_BIRTH_TEXT }).click();
+}
+
+async function attachScreenshot(page: Page, name: string) {
+	const buf = await page.screenshot({ type: 'png' });
+	await test.info().attach(name, { body: buf, contentType: 'image/png' });
+}
+
+// Tests ───────────────────────────────────────────────────────────────────────
+
+test.describe('v2.3 Birth Ritual — Visual proof', () => {
+	test.describe.configure({ mode: 'serial' });
+
+	test('1. /dashboard/graph mounts a WebGL canvas', async ({ page }) => {
+		await page.goto(GRAPH_URL);
+		const mounted = await isGraphMounted(page);
+
+		// If the graph didn't mount (no vestige-mcp backend), fixme gracefully —
+		// the remaining tests in this file require a canvas and would cascade.
+		test.fixme(
+			!mounted,
+			'Graph canvas did not mount — vestige-mcp backend likely not running on 127.0.0.1:3927. ' +
+			'Start the MCP server or run the infrastructure before re-enabling this suite.'
+		);
+
+		const canvas = page.locator('canvas');
+		await expect(canvas).toBeAttached();
+
+		await attachScreenshot(page, 'graph-canvas-mounted.png');
+	});
+
+	test('2. inject single birth via Settings button, screenshot timeline on Graph', async ({ page }) => {
+		const errors = captureErrors(page);
+
+		// Pre-flight: make sure the graph is reachable. Fixme if not.
+		await page.goto(GRAPH_URL);
+		const mounted = await isGraphMounted(page);
+		test.fixme(!mounted, 'Graph canvas not mounted — skipping birth ritual test.');
+
+		// Go to settings, fire the synthetic MemoryCreated event, then
+		// SPA-route back to graph. Using goto() instead of client-side
+		// navigation is fine: SvelteKit's adapter-static preserves module
+		// state across goto() within the same page context.
+		await injectBirthViaSettings(page);
+		const tInjected = Date.now();
+
+		await page.goto(GRAPH_URL);
+		await isGraphMounted(page);
+
+		// Take screenshots at the documented ritual waypoints, relative to
+		// the injection timestamp. Each attach() lands in the HTML report.
+		const waypoints: Array<{ t: number; label: string }> = [
+			{ t: 0,    label: 'birth-01-t0-injection.png' },
+			{ t: 500,  label: 'birth-02-t500-gestation-mid.png' },
+			{ t: 1200, label: 'birth-03-t1200-flight-start.png' },
+			{ t: 2000, label: 'birth-04-t2000-mid-flight.png' },
+			{ t: 2400, label: 'birth-05-t2400-near-arrival.png' },
+			{ t: 3000, label: 'birth-06-t3000-burst-cascade.png' },
+		];
+
+		for (const wp of waypoints) {
+			const waitMs = Math.max(0, wp.t - (Date.now() - tInjected));
+			if (waitMs > 0) await page.waitForTimeout(waitMs);
+			await attachScreenshot(page, wp.label);
+		}
+
+		// No unhandled errors during the ritual. The FATAL 6 regression would
+		// surface here.
+		expect(errors.pageErrors, `pageerror events: ${errors.pageErrors.map(e => e.message).join('; ')}`)
+			.toHaveLength(0);
+		expect(errors.consoleErrors, `console errors: ${errors.consoleErrors.join('; ')}`)
+			.toHaveLength(0);
+	});
+
+	test('3. multiple simultaneous births — no errors, canvas still responsive', async ({ page }) => {
+		const errors = captureErrors(page);
+
+		await page.goto(GRAPH_URL);
+		const mounted = await isGraphMounted(page);
+		test.fixme(!mounted, 'Graph canvas not mounted — skipping birth ritual test.');
+
+		// Fire 3 births back-to-back via the Settings button. Navigate to
+		// /settings once, click 3x, then return to /graph so all three events
+		// are in the feed when Graph3D mounts.
+		await page.goto(SETTINGS_URL);
+		const btn = page.getByRole('button', { name: TRIGGER_BIRTH_TEXT });
+		await expect(btn).toBeVisible();
+		await btn.click();
+		await btn.click();
+		await btn.click();
+
+		await page.goto(GRAPH_URL);
+		await isGraphMounted(page);
+
+		// Let the full 2.6s ritual play for all three orbs, with overlap.
+		await page.waitForTimeout(3500);
+		await attachScreenshot(page, 'birth-07-triple-birth.png');
+
+		// Canvas is still responsive: clicking in the middle should not hang
+		// the page. We don't care what's selected — just that the click
+		// dispatches without timing out.
+		const canvas = page.locator('canvas');
+		const box = await canvas.boundingBox();
+		if (box) {
+			await page.mouse.click(box.x + box.width / 2, box.y + box.height / 2, { timeout: 2000 });
+			await page.waitForTimeout(300);
+		}
+		await attachScreenshot(page, 'birth-08-post-click.png');
+
+		expect(errors.pageErrors, `pageerror events: ${errors.pageErrors.map(e => e.message).join('; ')}`)
+			.toHaveLength(0);
+		expect(errors.consoleErrors, `console errors: ${errors.consoleErrors.join('; ')}`)
+			.toHaveLength(0);
+	});
+});
diff --git a/apps/dashboard/e2e/pulse-toast.spec.ts b/apps/dashboard/e2e/pulse-toast.spec.ts
new file mode 100644
index 0000000..0424482
--- /dev/null
+++ b/apps/dashboard/e2e/pulse-toast.spec.ts
@@ -0,0 +1,235 @@
+// ─────────────────────────────────────────────────────────────────────────────
+// v2.2 Pulse Toast — E2E behaviour proof
+//
+// These tests exercise the InsightToast overlay (mounted in the root layout
+// at /src/routes/+layout.svelte) via the Settings page's "✦ Preview Pulse"
+// button. That button calls `fireDemoSequence()` which pushes 4 synthetic
+// toasts directly through the toast store — no WebSocket or MCP backend
+// required. This is why the pulse-toast tests are backend-agnostic and
+// should run reliably in CI without vestige-mcp.
+//
+// Coverage:
+//   1. First toast appears within 500ms of clicking Preview Pulse
+//   2. At peak of the 3.2s sequence, >= 2 toasts are visible simultaneously
+//   3. Click-to-dismiss removes a toast
+//   4. Hover pauses the 5.5s dwell timer (toast survives 8s hover)
+//   5. Keyboard Enter on focused toast dismisses it
+//   6. The `.toast-progress-fill` animation is paused during hover
+// ─────────────────────────────────────────────────────────────────────────────
+
+import { test, expect, type Page } from '@playwright/test';
+
+const SETTINGS_URL = '/dashboard/settings';
+const TOAST = '.toast-item';
+const PROGRESS_FILL = '.toast-progress-fill';
+const PREVIEW_PULSE_TEXT = /Preview Pulse/i;
+
+async function gotoSettings(page: Page) {
+	await page.goto(SETTINGS_URL);
+	// The Preview Pulse button lives inside the "Cognitive Operations" card.
+	// Wait for it before each test so clicks aren't racing hydration.
+	await expect(page.getByRole('button', { name: PREVIEW_PULSE_TEXT })).toBeVisible();
+}
+
+async function clearAllToasts(page: Page) {
+	// Dismiss any lingering toasts from a previous sub-test to keep counts clean.
+	const count = await page.locator(TOAST).count();
+	for (let i = 0; i < count; i++) {
+		const first = page.locator(TOAST).first();
+		if (await first.isVisible().catch(() => false)) {
+			await first.click({ timeout: 1000 }).catch(() => { /* race with auto-dismiss */ });
+		}
+	}
+	await expect(page.locator(TOAST)).toHaveCount(0, { timeout: 5000 });
+}
+
+async function firePulse(page: Page) {
+	await page.getByRole('button', { name: PREVIEW_PULSE_TEXT }).click();
+}
+
+test.describe('v2.2 Pulse Toast — Demo sequence', () => {
+	test('1. first toast appears promptly after clicking Preview Pulse', async ({ page }) => {
+		await gotoSettings(page);
+		await clearAllToasts(page);
+
+		await firePulse(page);
+
+		// The first demo toast is pushed via setTimeout(..., 0) in
+		// fireDemoSequence. After the setTimeout, Svelte reactive pipeline
+		// ticks, then the toast-in CSS animation (0.32s) brings opacity from
+		// 0→1. On a warm Vite cache this is well under a second; on a cold
+		// start with parallel workers it can spike to 3–4s. The assertion
+		// target is "promptly" — not a perf SLA — so allow up to 5s.
+		await expect(page.locator(TOAST).first()).toBeVisible({ timeout: 5000 });
+
+		await page.screenshot({
+			path: 'e2e/screenshots/pulse-01-first-toast.png',
+			fullPage: false,
+		});
+
+		await clearAllToasts(page);
+	});
+
+	test('2. peak stack shows at least 2 toasts simultaneously', async ({ page }) => {
+		await gotoSettings(page);
+		await clearAllToasts(page);
+
+		await firePulse(page);
+
+		// The demo fires 4 toasts at i*800ms = 0, 800, 1600, 2400. The first
+		// toast has dwellMs 7000, so at t=2500 all 4 should coexist.
+		// Poll the count through the sequence and capture the peak.
+		let peak = 0;
+		const until = Date.now() + 3500;
+		while (Date.now() < until) {
+			const n = await page.locator(TOAST).count();
+			if (n > peak) peak = n;
+			await page.waitForTimeout(120);
+		}
+
+		expect(peak).toBeGreaterThanOrEqual(2);
+
+		await page.screenshot({
+			path: 'e2e/screenshots/pulse-02-peak-stack.png',
+			fullPage: false,
+		});
+
+		await clearAllToasts(page);
+	});
+
+	test('3. click-to-dismiss removes the clicked toast', async ({ page }) => {
+		await gotoSettings(page);
+		await clearAllToasts(page);
+
+		await firePulse(page);
+		await expect(page.locator(TOAST).first()).toBeVisible({ timeout: 1000 });
+
+		// Capture the toast's accessibility label so we can assert *that exact*
+		// toast disappeared, independent of how many siblings stayed on screen.
+		const first = page.locator(TOAST).first();
+		const label = await first.getAttribute('aria-label');
+		expect(label).toBeTruthy();
+
+		await first.click();
+
+		await expect(
+			page.locator(`${TOAST}[aria-label="${label}"]`)
+		).toHaveCount(0, { timeout: 2000 });
+
+		await clearAllToasts(page);
+	});
+
+	test('4. hover pauses the dwell timer (toast survives 8s hover)', async ({ page }) => {
+		await gotoSettings(page);
+		await clearAllToasts(page);
+
+		await firePulse(page);
+		// Let the full 3.2s demo sequence complete so no more prepends happen
+		// during the hover window. This avoids any subtle layout churn from
+		// new toasts being added above the one we're about to hover on.
+		await page.waitForTimeout(3500);
+
+		// After the sequence settles, the DOM stack (newest-first at index 0)
+		// is: [ConsolidationCompleted, MemorySuppressed, ConnectionDiscovered,
+		//      DreamCompleted]. The last item (DreamCompleted) is the oldest
+		// and has the longest dwell (7000ms). It's anchored to the bottom of
+		// the stack — the most position-stable element. Hover-pause it and
+		// verify it outlives 8s of hover.
+		const stack = page.locator(TOAST);
+		const count = await stack.count();
+		expect(count).toBeGreaterThanOrEqual(2);
+
+		const target = stack.last();
+		const label = await target.getAttribute('aria-label');
+		expect(label).toBeTruthy();
+
+		await target.hover();
+		// Re-hover once after 3s and 6s to keep the mouse anchored on the
+		// element — defends against any micro-move that could trigger
+		// mouseleave. Pause is re-applied on each mouseenter, so this is safe.
+		await page.waitForTimeout(3000);
+		await target.hover();
+		await page.waitForTimeout(3000);
+		await target.hover();
+		await page.waitForTimeout(2200);
+
+		// If DreamCompleted's raw dwell (7s) without hover would have expired
+		// by now (t ≈ 8.2s after hover start); hover-pause must have kept it
+		// alive.
+		await expect(target).toBeVisible();
+
+		await page.screenshot({
+			path: 'e2e/screenshots/pulse-03-hover-pause.png',
+			fullPage: false,
+		});
+
+		// Mouseleave — move cursor far away to a non-interactive region.
+		// After leaving, dwell resumes with whatever time was remaining
+		// (>= 200ms floor). The toast should vanish within ~8s (generous
+		// to accommodate the 7000ms raw dwell plus a safety margin).
+		await page.mouse.move(0, 0);
+		await expect(
+			page.locator(`${TOAST}[aria-label="${label}"]`)
+		).toHaveCount(0, { timeout: 10_000 });
+
+		await clearAllToasts(page);
+	});
+
+	test('5. keyboard Enter on focused toast dismisses it', async ({ page }) => {
+		await gotoSettings(page);
+		await clearAllToasts(page);
+
+		await firePulse(page);
+		const first = page.locator(TOAST).first();
+		await expect(first).toBeVisible({ timeout: 1000 });
+
+		const label = await first.getAttribute('aria-label');
+		const target = page.locator(`${TOAST}[aria-label="${label}"]`);
+
+		// Toasts are <button> elements — they're focusable. focus() avoids
+		// relying on tab-order through the Settings page, which is unstable
+		// (depends on stat cards, form fields, and other affordances above it).
+		await target.focus();
+		await expect(target).toBeFocused();
+
+		await page.keyboard.press('Enter');
+
+		await expect(target).toHaveCount(0, { timeout: 2000 });
+
+		await clearAllToasts(page);
+	});
+
+	test('6. progress-fill animation is paused while hovering', async ({ page }) => {
+		await gotoSettings(page);
+		await clearAllToasts(page);
+
+		await firePulse(page);
+		const first = page.locator(TOAST).first();
+		await expect(first).toBeVisible({ timeout: 1000 });
+
+		// Hover, then read the computed animation-play-state on the inner fill.
+		// CSS rule: `.toast-item:hover .toast-progress-fill { animation-play-state: paused; }`.
+		await first.hover();
+
+		const playState = await first.locator(PROGRESS_FILL).evaluate(
+			(el) => window.getComputedStyle(el).animationPlayState
+		);
+		expect(playState).toBe('paused');
+
+		// Sanity: moving away resumes the animation.
+		await page.mouse.move(0, 0);
+		// Small settle so hover styles detach cleanly.
+		await page.waitForTimeout(100);
+
+		// The same toast may have already been dismissed in the small window.
+		// Guard the assertion so we don't fail on race between resume + dwell.
+		if (await first.isVisible().catch(() => false)) {
+			const running = await first.locator(PROGRESS_FILL).evaluate(
+				(el) => window.getComputedStyle(el).animationPlayState
+			);
+			expect(running).toBe('running');
+		}
+
+		await clearAllToasts(page);
+	});
+});
diff --git a/apps/dashboard/src/lib/graph/__tests__/effects.test.ts b/apps/dashboard/src/lib/graph/__tests__/effects.test.ts
index 9c80986..e495046 100644
--- a/apps/dashboard/src/lib/graph/__tests__/effects.test.ts
+++ b/apps/dashboard/src/lib/graph/__tests__/effects.test.ts
@@ -497,4 +497,505 @@ describe('EffectManager', () => {
 			expect(effects.pulseEffects.length).toBe(0);
 		});
 	});
+
+	describe('createBirthOrb (v2.3 Memory Birth Ritual)', () => {
+		// Build a camera with a Quaternion for createBirthOrb's view-space
+		// projection. The three-mock's applyQuaternion is identity, so the
+		// start position collapses to `camera.position + (0, 0, -distance)`.
+		function makeCamera() {
+			return {
+				position: new Vector3(0, 30, 80),
+				quaternion: new (class {
+					x = 0; y = 0; z = 0; w = 1;
+				})(),
+			} as any;
+		}
+
+		it('adds exactly 2 sprites to the scene on spawn', () => {
+			const cam = makeCamera();
+			const baseline = scene.children.length;
+			effects.createBirthOrb(
+				cam,
+				new Color(0x00ffd1) as any,
+				() => new Vector3(0, 0, 0) as any,
+				() => {}
+			);
+			expect(scene.children.length).toBe(baseline + 2);
+		});
+
+		it('both sprite and core use additive blending', () => {
+			const cam = makeCamera();
+			effects.createBirthOrb(
+				cam,
+				new Color(0xff8800) as any,
+				() => new Vector3(0, 0, 0) as any,
+				() => {}
+			);
+			const halo = scene.children[0] as any;
+			const core = scene.children[1] as any;
+			// AdditiveBlending constant from three-mock is 2
+			expect(halo.material.blending).toBe(2);
+			expect(core.material.blending).toBe(2);
+			// depthTest:false is passed to the SpriteMaterial constructor in
+			// effects.ts so the orb stays visible through other nodes. The
+			// three-mock's SpriteMaterial constructor does not persist this
+			// param, so we can't assert it at the instance level here; the
+			// production behavior is covered by ui-fixes.test.ts source grep.
+			expect(halo.material.transparent).toBe(true);
+			expect(core.material.transparent).toBe(true);
+		});
+
+		it('positions the orb at camera-relative cosmic center on spawn', () => {
+			const cam = makeCamera();
+			effects.createBirthOrb(
+				cam,
+				new Color(0x00ffd1) as any,
+				() => new Vector3(0, 0, 0) as any,
+				() => {},
+				{ distanceFromCamera: 40 }
+			);
+			const halo = scene.children[0] as any;
+			const core = scene.children[1] as any;
+			// mock applyQuaternion is identity, so startPos = camera.pos + (0,0,-40)
+			expect(halo.position.x).toBeCloseTo(0);
+			expect(halo.position.y).toBeCloseTo(30);
+			expect(halo.position.z).toBeCloseTo(40); // 80 + (-40)
+			expect(core.position.x).toBeCloseTo(halo.position.x);
+			expect(core.position.y).toBeCloseTo(halo.position.y);
+			expect(core.position.z).toBeCloseTo(halo.position.z);
+		});
+
+		it('gestation phase: position stays at startPos for all 48 frames', () => {
+			const cam = makeCamera();
+			effects.createBirthOrb(
+				cam,
+				new Color(0x00ffd1) as any,
+				() => new Vector3(100, 100, 100) as any, // far-away target
+				() => {}
+			);
+			const halo = scene.children[0] as any;
+			const startX = halo.position.x;
+			const startY = halo.position.y;
+			const startZ = halo.position.z;
+
+			for (let f = 0; f < 48; f++) {
+				effects.update(nodeMeshMap, cam);
+				expect(halo.position.x).toBeCloseTo(startX);
+				expect(halo.position.y).toBeCloseTo(startY);
+				expect(halo.position.z).toBeCloseTo(startZ);
+			}
+		});
+
+		it('gestation phase: opacity rises from 0 toward 0.95', () => {
+			const cam = makeCamera();
+			effects.createBirthOrb(
+				cam,
+				new Color(0x00ffd1) as any,
+				() => new Vector3(0, 0, 0) as any,
+				() => {}
+			);
+			const halo = scene.children[0] as any;
+			const core = scene.children[1] as any;
+
+			// Spawn opacity
+			expect(halo.material.opacity).toBe(0);
+			expect(core.material.opacity).toBe(0);
+
+			effects.update(nodeMeshMap, cam); // age 1
+			const earlyHaloOp = halo.material.opacity;
+			expect(earlyHaloOp).toBeGreaterThan(0);
+			expect(earlyHaloOp).toBeLessThan(0.2);
+
+			// Run to end of gestation
+			for (let f = 0; f < 47; f++) effects.update(nodeMeshMap, cam);
+			expect(halo.material.opacity).toBeCloseTo(0.95, 1);
+			expect(core.material.opacity).toBeCloseTo(1.0, 1);
+			// Monotonic-ish growth: late gestation > early gestation
+			expect(halo.material.opacity).toBeGreaterThan(earlyHaloOp);
+		});
+
+		it('gestation phase: sprite scale grows substantially', () => {
+			const cam = makeCamera();
+			effects.createBirthOrb(
+				cam,
+				new Color(0x00ffd1) as any,
+				() => new Vector3(0, 0, 0) as any,
+				() => {}
+			);
+			const halo = scene.children[0] as any;
+
+			effects.update(nodeMeshMap, cam); // age 1
+			const earlyScale = halo.scale.x;
+
+			for (let f = 0; f < 47; f++) effects.update(nodeMeshMap, cam); // age 48
+			const lateScale = halo.scale.x;
+
+			// Halo grows from ~0.5 toward ~5 during gestation (with pulse variation).
+			expect(lateScale).toBeGreaterThan(earlyScale);
+			expect(lateScale).toBeGreaterThan(2);
+		});
+
+		it('gestation phase: halo color tints toward event color', () => {
+			const cam = makeCamera();
+			const eventColor = new Color(0xff0000); // pure red
+			effects.createBirthOrb(
+				cam,
+				eventColor as any,
+				() => new Vector3(0, 0, 0) as any,
+				() => {}
+			);
+			const halo = scene.children[0] as any;
+
+			effects.update(nodeMeshMap, cam); // age 1 — factor ≈ 0.72
+			const earlyR = halo.material.color.r;
+
+			for (let f = 0; f < 47; f++) effects.update(nodeMeshMap, cam); // age 48 — factor = 1.0
+			const lateR = halo.material.color.r;
+
+			// Red channel should approach the event color's red (1.0) from a dimmer value
+			expect(lateR).toBeGreaterThan(earlyR);
+			expect(lateR).toBeCloseTo(1.0, 1);
+			// Green/blue stay at 0 (event color is pure red)
+			expect(halo.material.color.g).toBeCloseTo(0);
+			expect(halo.material.color.b).toBeCloseTo(0);
+		});
+
+		it('flight phase: Bezier arc passes ABOVE the linear midpoint at t=0.5', () => {
+			const cam = makeCamera();
+			// startPos = (0, 30, 40), target = (0, 0, 0)
+			// linear midpoint y = 15; control point y = 15 + 30 + dist*0.15 = 52.5
+			effects.createBirthOrb(
+				cam,
+				new Color(0x00ffd1) as any,
+				() => new Vector3(0, 0, 0) as any,
+				() => {}
+			);
+			const halo = scene.children[0] as any;
+
+			// Drive past gestation (48) + half of flight (45) = 93 frames → t=0.5
+			for (let f = 0; f < 93; f++) effects.update(nodeMeshMap, cam);
+
+			// Linear midpoint y is 15; Bezier midpoint should be notably higher.
+			expect(halo.position.y).toBeGreaterThan(15);
+			// And not as high as the control point itself (52.5) — Bezier
+			// passes through midpoint-ish at t=0.5, biased upward by the arc.
+			expect(halo.position.y).toBeLessThan(52.5);
+		});
+
+		it('flight phase: orb moves from startPos toward target', () => {
+			const cam = makeCamera();
+			effects.createBirthOrb(
+				cam,
+				new Color(0x00ffd1) as any,
+				() => new Vector3(0, 0, 0) as any,
+				() => {}
+			);
+			const halo = scene.children[0] as any;
+
+			// End of gestation
+			for (let f = 0; f < 48; f++) effects.update(nodeMeshMap, cam);
+			const gestZ = halo.position.z;
+
+			// One tick into flight
+			effects.update(nodeMeshMap, cam);
+			const earlyFlightZ = halo.position.z;
+
+			// Near end of flight
+			for (let f = 0; f < 88; f++) effects.update(nodeMeshMap, cam);
+			const lateFlightZ = halo.position.z;
+
+			// Z moves from 40 toward 0
+			expect(earlyFlightZ).toBeLessThan(gestZ);
+			expect(lateFlightZ).toBeLessThan(earlyFlightZ);
+			expect(lateFlightZ).toBeLessThan(5); // close to target z=0
+		});
+
+		it('dynamic target tracking: changing getTargetPos mid-flight redirects the orb', () => {
+			const cam = makeCamera();
+			let target = new Vector3(0, 0, 0);
+			effects.createBirthOrb(
+				cam,
+				new Color(0x00ffd1) as any,
+				() => target as any,
+				() => {}
+			);
+			const halo = scene.children[0] as any;
+
+			// Drive to mid-flight (gestation 48 + 30 flight frames = 78)
+			for (let f = 0; f < 78; f++) effects.update(nodeMeshMap, cam);
+			const xBeforeRedirect = halo.position.x;
+
+			// Redirect target far to the +X side
+			target = new Vector3(200, 0, 0);
+
+			// A few more flight frames — orb should track the new target
+			for (let f = 0; f < 10; f++) effects.update(nodeMeshMap, cam);
+			const xAfterRedirect = halo.position.x;
+
+			// With the original target at (0,0,0), x stays near 0 throughout.
+			// After redirect, x should swing toward the new target's +200.
+			expect(xAfterRedirect).toBeGreaterThan(xBeforeRedirect + 5);
+		});
+
+		it('onArrive fires exactly once at frame 139 (totalFrames + 1)', () => {
+			const cam = makeCamera();
+			let arriveCount = 0;
+			effects.createBirthOrb(
+				cam,
+				new Color(0x00ffd1) as any,
+				() => new Vector3(0, 0, 0) as any,
+				() => {
+					arriveCount++;
+				}
+			);
+
+			// Drive through gestation (48) + flight (90) = 138 frames. Should NOT have fired.
+			for (let f = 0; f < 138; f++) effects.update(nodeMeshMap, cam);
+			expect(arriveCount).toBe(0);
+
+			// Frame 139 — fires onArrive
+			effects.update(nodeMeshMap, cam);
+			expect(arriveCount).toBe(1);
+
+			// Drive many more frames — must stay at 1
+			for (let f = 0; f < 50; f++) effects.update(nodeMeshMap, cam);
+			expect(arriveCount).toBe(1);
+		});
+
+		it('post-arrival fade: orb disposes from scene after ~8 fade frames', () => {
+			const cam = makeCamera();
+			const baseline = scene.children.length;
+			effects.createBirthOrb(
+				cam,
+				new Color(0x00ffd1) as any,
+				() => new Vector3(0, 0, 0) as any,
+				() => {}
+			);
+			expect(scene.children.length).toBe(baseline + 2);
+
+			// Gestation + flight + arrive + fade = 138 + 1 + 8 = 147 frames
+			for (let f = 0; f < 150; f++) effects.update(nodeMeshMap, cam);
+
+			// Both orb sprites should be gone
+			expect(scene.children.length).toBe(baseline);
+		});
+
+		it('onArrive callback wrapped in try/catch so a throw does not crash the loop', () => {
+			const cam = makeCamera();
+			effects.createBirthOrb(
+				cam,
+				new Color(0x00ffd1) as any,
+				() => new Vector3(0, 0, 0) as any,
+				() => {
+					throw new Error('caller blew up');
+				}
+			);
+
+			// Should not throw — the production code swallows arrival-callback errors.
+			expect(() => {
+				for (let f = 0; f < 160; f++) effects.update(nodeMeshMap, cam);
+			}).not.toThrow();
+		});
+
+		it('Sanhedrin Shatter: onArrive NEVER fires when target vanishes mid-flight', () => {
+			const cam = makeCamera();
+			let arriveCount = 0;
+			let target: Vector3 | undefined = new Vector3(0, 0, 0);
+
+			effects.createBirthOrb(
+				cam,
+				new Color(0x00ffd1) as any,
+				() => target as any,
+				() => {
+					arriveCount++;
+				}
+			);
+
+			// Finish gestation (48 frames) with target present
+			for (let f = 0; f < 48; f++) effects.update(nodeMeshMap, cam);
+			expect(arriveCount).toBe(0);
+
+			// Stop hook yanks the target mid-flight
+			target = undefined;
+
+			// Run enough frames to cover the entire orb lifecycle
+			for (let f = 0; f < 200; f++) effects.update(nodeMeshMap, cam);
+
+			// onArrive must NEVER fire on aborted orbs
+			expect(arriveCount).toBe(0);
+		});
+
+		it('Sanhedrin Shatter: implosion is spawned when target vanishes mid-flight', () => {
+			const cam = makeCamera();
+			let target: Vector3 | undefined = new Vector3(0, 0, 0);
+
+			const baseline = scene.children.length;
+			effects.createBirthOrb(
+				cam,
+				new Color(0x00ffd1) as any,
+				() => target as any,
+				() => {}
+			);
+			// baseline + 2 sprites
+			expect(scene.children.length).toBe(baseline + 2);
+
+			// Finish gestation
+			for (let f = 0; f < 48; f++) effects.update(nodeMeshMap, cam);
+
+			// Yank target → abort triggers on next tick
+			target = undefined;
+			const beforeAbort = scene.children.length;
+			effects.update(nodeMeshMap, cam);
+			// Scene should have grown by at least 1 (the implosion particles)
+			expect(scene.children.length).toBeGreaterThan(beforeAbort);
+		});
+
+		it('Sanhedrin Shatter: halo turns blood-red on abort', () => {
+			const cam = makeCamera();
+			let target: Vector3 | undefined = new Vector3(0, 0, 0);
+
+			effects.createBirthOrb(
+				cam,
+				new Color(0x00ffd1) as any, // cyan — NOT red
+				() => target as any,
+				() => {}
+			);
+			const halo = scene.children[0] as any;
+
+			// Finish gestation
+			for (let f = 0; f < 48; f++) effects.update(nodeMeshMap, cam);
+
+			// Sanity: halo is NOT red yet (event color cyan has r≈0)
+			expect(halo.material.color.r).toBeLessThan(0.5);
+
+			// Yank target; abort triggers next tick
+			target = undefined;
+			effects.update(nodeMeshMap, cam);
+
+			// Halo should now be blood red (1.0, 0.15, 0.2)
+			expect(halo.material.color.r).toBeGreaterThan(0.9);
+			expect(halo.material.color.g).toBeLessThan(0.3);
+			expect(halo.material.color.b).toBeLessThan(0.3);
+		});
+
+		it('Sanhedrin Shatter: orb eventually disposes from scene', () => {
+			const cam = makeCamera();
+			let target: Vector3 | undefined = new Vector3(0, 0, 0);
+
+			const baseline = scene.children.length;
+			effects.createBirthOrb(
+				cam,
+				new Color(0x00ffd1) as any,
+				() => target as any,
+				() => {}
+			);
+
+			// Finish gestation
+			for (let f = 0; f < 48; f++) effects.update(nodeMeshMap, cam);
+			// Yank target
+			target = undefined;
+
+			// Drive a long time — orb + implosion should both dispose
+			// (orb fade ~8 frames, implosion lifetime ~80 frames)
+			for (let f = 0; f < 200; f++) effects.update(nodeMeshMap, cam);
+
+			expect(scene.children.length).toBe(baseline);
+		});
+
+		it('dispose() removes active birth orbs from the scene', () => {
+			const cam = makeCamera();
+			effects.createBirthOrb(
+				cam,
+				new Color(0x00ffd1) as any,
+				() => new Vector3(0, 0, 0) as any,
+				() => {}
+			);
+			effects.createBirthOrb(
+				cam,
+				new Color(0xff00ff) as any,
+				() => new Vector3(10, 10, 10) as any,
+				() => {}
+			);
+			// 4 sprites in scene (2 per orb)
+			expect(scene.children.length).toBeGreaterThanOrEqual(4);
+
+			effects.dispose();
+
+			// All orb sprites should be gone
+			expect(scene.children.length).toBe(0);
+		});
+
+		it('multiple orbs in flight: all 3 onArrive callbacks fire exactly once each', () => {
+			const cam = makeCamera();
+			let c1 = 0, c2 = 0, c3 = 0;
+
+			effects.createBirthOrb(
+				cam,
+				new Color(0xff0000) as any,
+				() => new Vector3(10, 0, 0) as any,
+				() => { c1++; }
+			);
+			effects.createBirthOrb(
+				cam,
+				new Color(0x00ff00) as any,
+				() => new Vector3(-10, 0, 0) as any,
+				() => { c2++; }
+			);
+			effects.createBirthOrb(
+				cam,
+				new Color(0x0000ff) as any,
+				() => new Vector3(0, 0, -10) as any,
+				() => { c3++; }
+			);
+
+			// Drive past arrival (139) with margin
+			for (let f = 0; f < 160; f++) effects.update(nodeMeshMap, cam);
+
+			expect(c1).toBe(1);
+			expect(c2).toBe(1);
+			expect(c3).toBe(1);
+		});
+
+		it('custom gestation/flight frame counts are honored', () => {
+			const cam = makeCamera();
+			let arriveCount = 0;
+			effects.createBirthOrb(
+				cam,
+				new Color(0x00ffd1) as any,
+				() => new Vector3(0, 0, 0) as any,
+				() => { arriveCount++; },
+				{ gestationFrames: 10, flightFrames: 20 }
+			);
+
+			// Before frame 31 — no arrival
+			for (let f = 0; f < 30; f++) effects.update(nodeMeshMap, cam);
+			expect(arriveCount).toBe(0);
+
+			// Frame 31 — fires
+			effects.update(nodeMeshMap, cam);
+			expect(arriveCount).toBe(1);
+		});
+
+		it('zero-alloc invariant (advisory): flight phase runs without throwing across many orbs', () => {
+			// Advisory test — vitest has no allocator introspection, but the
+			// inline algebraic Bezier eval in effects.ts is intentionally zero-
+			// allocation per frame (no `new Vector3`, no `new QuadraticBezierCurve3`).
+			// Here we just smoke-test that running many orbs across the full
+			// flight phase does not throw and completes cleanly.
+			const cam = makeCamera();
+			for (let k = 0; k < 6; k++) {
+				effects.createBirthOrb(
+					cam,
+					new Color(0x00ffd1) as any,
+					() => new Vector3(k * 5, 0, 0) as any,
+					() => {}
+				);
+			}
+			expect(() => {
+				for (let f = 0; f < 150; f++) effects.update(nodeMeshMap, cam);
+			}).not.toThrow();
+			// All orbs should have cleaned up
+			expect(scene.children.length).toBe(0);
+		});
+	});
 });
diff --git a/apps/dashboard/src/lib/graph/__tests__/events.test.ts b/apps/dashboard/src/lib/graph/__tests__/events.test.ts
index 8746597..c4061a1 100644
--- a/apps/dashboard/src/lib/graph/__tests__/events.test.ts
+++ b/apps/dashboard/src/lib/graph/__tests__/events.test.ts
@@ -10,7 +10,7 @@ import { NodeManager } from '../nodes';
 import { EdgeManager } from '../edges';
 import { EffectManager } from '../effects';
 import { ForceSimulation } from '../force-sim';
-import { Vector3, Scene } from './three-mock';
+import { Vector3, Scene, RingGeometry, Mesh, Points, Sprite } from './three-mock';
 import { makeNode, makeEdge, makeEvent, resetNodeCounter } from './helpers';
 import type { GraphNode, VestigeEvent } from '$types';
 
@@ -874,4 +874,270 @@ describe('Event-to-Mutation Pipeline', () => {
 			expect(mutations.some((m) => m.type === 'edgeAdded')).toBe(true);
 		});
 	});
+
+	describe('v2.3 Birth Ritual wiring', () => {
+		/** Count shockwave rings currently in the scene by their RingGeometry. */
+		function countRings(s: InstanceType<typeof Scene>): number {
+			let n = 0;
+			for (const child of s.children) {
+				if (child instanceof Mesh && child.geometry instanceof RingGeometry) n++;
+			}
+			return n;
+		}
+
+		/** Count Points children — rainbow bursts, spawn bursts, implosions. */
+		function countPoints(s: InstanceType<typeof Scene>): number {
+			let n = 0;
+			for (const child of s.children) if (child instanceof Points) n++;
+			return n;
+		}
+
+		/** Count Sprite children — birth orb adds a halo + core sprite. */
+		function countSprites(s: InstanceType<typeof Scene>): number {
+			let n = 0;
+			for (const child of s.children) if (child instanceof Sprite) n++;
+			return n;
+		}
+
+		it('node mesh is hidden immediately after MemoryCreated dispatch', () => {
+			mapEventToEffects(
+				makeEvent('MemoryCreated', {
+					id: 'ritual-create',
+					content: 'fresh memory',
+					node_type: 'fact',
+				}),
+				ctx,
+				allNodes
+			);
+
+			// Ritual path: mesh/glow/label are all .visible = false until
+			// igniteNode fires on orb arrival.
+			const mesh = nodeManager.meshMap.get('ritual-create')!;
+			const glow = nodeManager.glowMap.get('ritual-create')!;
+			const label = nodeManager.labelSprites.get('ritual-create')!;
+			expect(mesh.visible).toBe(false);
+			expect(glow.visible).toBe(false);
+			expect(label.visible).toBe(false);
+
+			// Pending sentinel is stamped on userData.
+			expect(mesh.userData.birthRitualPending).toBeDefined();
+		});
+
+		it('does NOT fire burst/ripple/shockwave at spawn (only the birth orb)', () => {
+			const ringsBefore = countRings(scene);
+			const pointsBefore = countPoints(scene);
+			const spritesBefore = countSprites(scene);
+
+			mapEventToEffects(
+				makeEvent('MemoryCreated', {
+					id: 'spawn-quiet',
+					content: 'test',
+					node_type: 'fact',
+				}),
+				ctx,
+				allNodes
+			);
+
+			// Birth orb adds exactly 2 sprites (halo + core). NodeManager's
+			// addNode also adds a glow Sprite + label Sprite to the NodeManager
+			// GROUP, not to the scene — so spritesBefore -> after delta is +2.
+			expect(countSprites(scene) - spritesBefore).toBe(2);
+
+			// No arrival-cascade effects yet: no shockwave rings, no rainbow
+			// burst/spawn burst/ripple particles.
+			expect(countRings(scene)).toBe(ringsBefore);
+			expect(countPoints(scene)).toBe(pointsBefore);
+		});
+
+		it('drives through the full ritual: onArrive fires, node becomes visible, scale grows', () => {
+			mapEventToEffects(
+				makeEvent('MemoryCreated', {
+					id: 'full-ritual',
+					content: 'visible after arrival',
+					node_type: 'fact',
+				}),
+				ctx,
+				allNodes
+			);
+
+			const mesh = nodeManager.meshMap.get('full-ritual')!;
+			expect(mesh.visible).toBe(false);
+
+			// Drive the effects update loop past the full ritual duration
+			// (gestation 48 + flight 90 = 138 frames). After frame 138 the
+			// orb fires onArrive which ignites the node and queues materialization.
+			for (let i = 0; i < 140; i++) {
+				effects.update(nodeManager.meshMap, camera, nodeManager.positions);
+			}
+
+			// Node is now visible and sentinel is cleared.
+			expect(mesh.visible).toBe(true);
+			expect(mesh.userData.birthRitualPending).toBeUndefined();
+
+			// Run node animation a few frames to let materialization scale grow.
+			// Note: onArrive bumped scale by 1.8x (from 0.001 -> 0.0018), then
+			// materialization easeOutElastic pulls it toward targetScale.
+			for (let f = 0; f < 10; f++) {
+				nodeManager.animate(f * 0.016, allNodes, camera);
+			}
+			expect(mesh.scale.x).toBeGreaterThan(0.001);
+		});
+
+		it("Newton's Cradle — target mesh scale is multiplied by 1.8x on arrival", () => {
+			mapEventToEffects(
+				makeEvent('MemoryCreated', {
+					id: 'newton-cradle',
+					content: 'recoil test',
+					node_type: 'fact',
+				}),
+				ctx,
+				allNodes
+			);
+
+			const mesh = nodeManager.meshMap.get('newton-cradle')!;
+			// Pre-arrival: scale is the addNode initial 0.001.
+			expect(mesh.scale.x).toBeCloseTo(0.001, 6);
+
+			// Drive just to the moment onArrive fires. Gestation (48) +
+			// flight (90) = 138 frames. Arrival bumps scale by 1.8x BEFORE
+			// materialization has run any ticks, so the scale should be
+			// exactly 0.001 * 1.8 = 0.0018 at that instant. We check right
+			// after onArrive (frame 139) — but effects.update progresses the
+			// orb's age counter by one each call, and on the tick where
+			// orb.age > totalFrames, onArrive fires. We then must NOT tick
+			// nodeManager.animate (or materialization would diverge the scale).
+			for (let i = 0; i < 140; i++) {
+				effects.update(nodeManager.meshMap, camera, nodeManager.positions);
+			}
+
+			// onArrive fired. Scale was 0.001, got multiplied by 1.8 -> 0.0018.
+			// Materialization is queued but hasn't run yet (no animate() calls).
+			expect(mesh.scale.x).toBeCloseTo(0.0018, 6);
+		});
+
+		it('dual shockwave — arrival cascade adds TWO RingGeometry meshes, not one', () => {
+			mapEventToEffects(
+				makeEvent('MemoryCreated', {
+					id: 'dual-shock',
+					content: 'layered crash',
+					node_type: 'fact',
+				}),
+				ctx,
+				allNodes
+			);
+
+			const ringsBefore = countRings(scene);
+
+			// Drive past full ritual so onArrive fires.
+			for (let i = 0; i < 140; i++) {
+				effects.update(nodeManager.meshMap, camera, nodeManager.positions);
+			}
+
+			// Both shockwaves fire synchronously in the onArrive callback
+			// (the previous setTimeout-delayed second shockwave was dropped
+			// because it could outlive the scene on route change).
+			const ringsAfter = countRings(scene);
+			expect(ringsAfter - ringsBefore).toBe(2);
+		});
+
+		it('re-reads position on arrival — fires cascade at force-sim-moved position', () => {
+			mapEventToEffects(
+				makeEvent('MemoryCreated', {
+					id: 'moving-target',
+					content: 'follow the node',
+					node_type: 'fact',
+				}),
+				ctx,
+				allNodes
+			);
+
+			// Grab the spawn position, then mutate it to simulate the force
+			// simulation pushing the node during the ritual.
+			const movedPos = new Vector3(123, 456, -789);
+			nodeManager.positions.set('moving-target', movedPos);
+
+			// Drive past full ritual.
+			for (let i = 0; i < 140; i++) {
+				effects.update(nodeManager.meshMap, camera, nodeManager.positions);
+			}
+
+			// The onArrive callback re-reads nodeManager.positions and fires
+			// the cascade at the LIVE position. The two shockwave Ring meshes
+			// should have been created at movedPos. Find them and check.
+			const rings = scene.children.filter(
+				(c) => c instanceof Mesh && c.geometry instanceof RingGeometry
+			);
+			expect(rings.length).toBeGreaterThanOrEqual(2);
+			// Rings for this node: their .position copies from arrivePos at
+			// spawn time inside createShockwave.
+			const atMovedPos = rings.filter(
+				(r) => r.position.x === 123 && r.position.y === 456 && r.position.z === -789
+			);
+			expect(atMovedPos.length).toBe(2);
+		});
+
+		it('Sanhedrin abort path — removeNode before arrival prevents the regular cascade', () => {
+			// Spy on the three arrival-cascade emitters so we can assert
+			// they were NEVER called when the target is vetoed mid-ritual.
+			const burstSpy = vi.spyOn(effects, 'createRainbowBurst');
+			const shockwaveSpy = vi.spyOn(effects, 'createShockwave');
+			const rippleSpy = vi.spyOn(effects, 'createRippleWave');
+
+			mapEventToEffects(
+				makeEvent('MemoryCreated', {
+					id: 'vetoed',
+					content: 'about to be shattered',
+					node_type: 'fact',
+				}),
+				ctx,
+				allNodes
+			);
+
+			// The orb's getTargetPos() closure reads
+			// nodeManager.positions.get('vetoed'). Dropping the position
+			// directly simulates the "target gone" state that the Sanhedrin
+			// veto produces after dissolution completes — without needing to
+			// drive the full 60-frame dissolution animation.
+			nodeManager.positions.delete('vetoed');
+			expect(nodeManager.positions.has('vetoed')).toBe(false);
+
+			// Snapshot the orb reference before the update loop disposes it.
+			// The abort branch flips `aborted` and tints the halo red; we
+			// assert on those fields after the ritual unwinds.
+			const orbs = (effects as any).birthOrbs as Array<{
+				sprite: { material: { color: any } };
+				core: { material: { color: any } };
+				aborted: boolean;
+			}>;
+			expect(orbs.length).toBe(1);
+			const orbRef = orbs[0];
+
+			// Drive effects past the full ritual. During flight the orb will
+			// see getTargetPos() === undefined, enter the Sanhedrin branch,
+			// call createImplosion (anti-birth visual) and SKIP onArrive —
+			// so the regular rainbow-burst + dual-shockwave + ripple cascade
+			// never fires.
+			for (let i = 0; i < 200; i++) {
+				effects.update(nodeManager.meshMap, camera, nodeManager.positions);
+			}
+
+			// Core assertion: the three regular-cascade emitters were never
+			// invoked for the vetoed node.
+			expect(burstSpy).not.toHaveBeenCalled();
+			expect(shockwaveSpy).not.toHaveBeenCalled();
+			expect(rippleSpy).not.toHaveBeenCalled();
+
+			// Also confirm the orb actually took the abort branch, not the
+			// gestation-only no-op path (otherwise this test would pass for
+			// the wrong reason). The aborted flag is set exactly once inside
+			// the Sanhedrin branch.
+			expect(orbRef.aborted).toBe(true);
+			expect(orbRef.sprite.material.color.r).toBeCloseTo(1.0, 3);
+			expect(orbRef.sprite.material.color.g).toBeCloseTo(0.15, 3);
+
+			burstSpy.mockRestore();
+			shockwaveSpy.mockRestore();
+			rippleSpy.mockRestore();
+		});
+	});
 });
diff --git a/apps/dashboard/src/lib/graph/__tests__/nodes.test.ts b/apps/dashboard/src/lib/graph/__tests__/nodes.test.ts
index 3d533f8..26b997f 100644
--- a/apps/dashboard/src/lib/graph/__tests__/nodes.test.ts
+++ b/apps/dashboard/src/lib/graph/__tests__/nodes.test.ts
@@ -453,4 +453,201 @@ describe('NodeManager', () => {
 			// The dispose method clears materializingNodes, dissolvingNodes, growingNodes
 		});
 	});
+
+	describe('Birth Ritual integration', () => {
+		it('addNode with isBirthRitual:true hides mesh, glow, and label immediately', () => {
+			const node = makeNode({ id: 'ritual-1' });
+			manager.addNode(node, new Vector3(5, 5, 5), { isBirthRitual: true });
+
+			const mesh = manager.meshMap.get('ritual-1')!;
+			const glow = manager.glowMap.get('ritual-1')!;
+			const label = manager.labelSprites.get('ritual-1')!;
+
+			expect(mesh.visible).toBe(false);
+			expect(glow.visible).toBe(false);
+			expect(label.visible).toBe(false);
+		});
+
+		it('addNode with isBirthRitual:true stores a pending sentinel on mesh.userData', () => {
+			const node = makeNode({ id: 'ritual-sentinel', retention: 0.75 });
+			manager.addNode(node, new Vector3(0, 0, 0), { isBirthRitual: true });
+
+			const mesh = manager.meshMap.get('ritual-sentinel')!;
+			const pending = mesh.userData.birthRitualPending as any;
+			expect(pending).toBeDefined();
+			expect(pending.totalFrames).toBe(30);
+			// targetScale = 0.5 + retention * 2 = 0.5 + 0.75 * 2 = 2.0
+			expect(pending.targetScale).toBeCloseTo(2.0, 3);
+		});
+
+		it('addNode with isBirthRitual:true does NOT enqueue materialization', () => {
+			const ritualNode = makeNode({ id: 'ritual-pending', retention: 0.8 });
+			manager.addNode(ritualNode, new Vector3(10, 10, 10), { isBirthRitual: true });
+
+			// In the real runtime the ritual-pending node is .visible=false
+			// AND is not yet in the GraphNode[] list — it only gets added to
+			// the visible node list once igniteNode flips its visibility and
+			// materialization kicks in. So we pass an empty `nodes` array to
+			// animate(), which also exercises that the breathing loop skips
+			// meshes absent from the nodes array.
+			const camera = { position: new Vector3(0, 30, 80) } as any;
+			for (let f = 0; f < 40; f++) {
+				manager.animate(f * 0.016, [], camera);
+			}
+
+			const mesh = manager.meshMap.get('ritual-pending')!;
+			// Materialization queue never pushed — a regular materializing
+			// node would be at scale ≈ targetScale = 2.1 by frame 40. The
+			// ritual-pending node stays at its addNode initial 0.001 because
+			// no animation loop is mutating its scale.
+			expect(mesh.scale.x).toBeCloseTo(0.001, 3);
+
+			// Stronger invariant — the sentinel is still there, confirming
+			// the node never got handed off to the materialization queue.
+			expect(mesh.userData.birthRitualPending).toBeDefined();
+		});
+
+		it('addNode without opts proceeds with normal materialization (old behavior)', () => {
+			const node = makeNode({ id: 'normal-spawn' });
+			manager.addNode(node, new Vector3(1, 2, 3));
+
+			const mesh = manager.meshMap.get('normal-spawn')!;
+			const glow = manager.glowMap.get('normal-spawn')!;
+			const label = manager.labelSprites.get('normal-spawn')!;
+
+			// Default mesh.visible is true in three-mock (Object3D has no explicit field).
+			// Key invariant: visible is NOT explicitly false like the ritual path.
+			expect(mesh.visible).not.toBe(false);
+			expect(glow.visible).not.toBe(false);
+			expect(label.visible).not.toBe(false);
+
+			// And no pending sentinel
+			expect(mesh.userData.birthRitualPending).toBeUndefined();
+
+			// Animation should proceed — scale grows via easeOutElastic
+			const camera = { position: new Vector3(0, 30, 80) } as any;
+			for (let f = 0; f < 20; f++) {
+				manager.animate(f * 0.016, [node], camera);
+			}
+			expect(mesh.scale.x).toBeGreaterThan(0.1);
+		});
+
+		it('igniteNode flips all three visibility flags and queues materialization', () => {
+			const node = makeNode({ id: 'to-ignite', retention: 0.6 });
+			manager.addNode(node, new Vector3(0, 0, 0), { isBirthRitual: true });
+
+			// Pre-ignite: hidden
+			const mesh = manager.meshMap.get('to-ignite')!;
+			const glow = manager.glowMap.get('to-ignite')!;
+			const label = manager.labelSprites.get('to-ignite')!;
+			expect(mesh.visible).toBe(false);
+
+			manager.igniteNode('to-ignite');
+
+			// Post-ignite: visible
+			expect(mesh.visible).toBe(true);
+			expect(glow.visible).toBe(true);
+			expect(label.visible).toBe(true);
+
+			// Sentinel is gone
+			expect(mesh.userData.birthRitualPending).toBeUndefined();
+
+			// Materialization was queued — drive animation and the scale
+			// should grow past the initial 0.001.
+			const camera = { position: new Vector3(0, 30, 80) } as any;
+			for (let f = 0; f < 15; f++) {
+				manager.animate(f * 0.016, [node], camera);
+			}
+			expect(mesh.scale.x).toBeGreaterThan(0.1);
+		});
+
+		it('igniteNode called twice is idempotent (second call is a no-op)', () => {
+			const node = makeNode({ id: 'double-ignite', retention: 0.5 });
+			manager.addNode(node, new Vector3(0, 0, 0), { isBirthRitual: true });
+
+			manager.igniteNode('double-ignite');
+			// Capture scale after one round of animation
+			const camera = { position: new Vector3(0, 30, 80) } as any;
+			for (let f = 0; f < 10; f++) {
+				manager.animate(f * 0.016, [node], camera);
+			}
+			const scaleAfterFirst = manager.meshMap.get('double-ignite')!.scale.x;
+
+			// Second ignite — should NOT push a duplicate materialization entry.
+			// If it did, the extra entry (starting at frame 0) would restart
+			// the scale back near 0.001 or at least visibly reset it.
+			manager.igniteNode('double-ignite');
+			for (let f = 0; f < 5; f++) {
+				manager.animate((f + 10) * 0.016, [node], camera);
+			}
+			const scaleAfterSecond = manager.meshMap.get('double-ignite')!.scale.x;
+
+			// Scale after second ignite should be greater than or roughly equal
+			// to scale after first, NOT reset toward 0.001. A duplicate entry
+			// starting at frame 0 would pull the mesh back near zero on the
+			// very first subsequent animate() tick via mn.mesh.scale.setScalar.
+			expect(scaleAfterSecond).toBeGreaterThanOrEqual(scaleAfterFirst * 0.5);
+		});
+
+		it('igniteNode on a regular (non-ritual) node is a no-op', () => {
+			const node = makeNode({ id: 'regular', retention: 0.5 });
+			manager.addNode(node, new Vector3(0, 0, 0));
+			// Regular addNode already queued materialization. Capture state.
+			const mesh = manager.meshMap.get('regular')!;
+			const visBefore = mesh.visible;
+
+			// Call igniteNode — there's no pending sentinel, should short-circuit.
+			expect(() => manager.igniteNode('regular')).not.toThrow();
+
+			// No pending sentinel means the function returns early after the
+			// sentinel check, so nothing about the mesh changes.
+			expect(mesh.visible).toBe(visBefore);
+			expect(mesh.userData.birthRitualPending).toBeUndefined();
+		});
+
+		it('igniteNode on unknown id is a no-op (no throw)', () => {
+			expect(() => manager.igniteNode('does-not-exist')).not.toThrow();
+			expect(manager.meshMap.has('does-not-exist')).toBe(false);
+		});
+
+		it('position is stored in positions map even when the node is invisible', () => {
+			const node = makeNode({ id: 'invisible-but-positioned' });
+			const spawnPos = new Vector3(42, -17, 8);
+			manager.addNode(node, spawnPos, { isBirthRitual: true });
+
+			// Force simulation + orb getTargetPos() both rely on positions
+			// being live immediately — the ritual only hides visuals, not
+			// physics state.
+			const stored = manager.positions.get('invisible-but-positioned');
+			expect(stored).toBeDefined();
+			expect(stored!.x).toBe(42);
+			expect(stored!.y).toBe(-17);
+			expect(stored!.z).toBe(8);
+
+			// And the mesh itself is still hidden
+			expect(manager.meshMap.get('invisible-but-positioned')!.visible).toBe(false);
+		});
+
+		it('removeNode during pending ritual cancels without materialization', () => {
+			// Sanhedrin abort path at the NodeManager level: a ritual-pending
+			// node gets removed before igniteNode fires. The remove path
+			// should still work (dissolution queue takes over) and igniteNode
+			// called later must not resurrect it.
+			const node = makeNode({ id: 'aborted-ritual' });
+			manager.addNode(node, new Vector3(0, 0, 0), { isBirthRitual: true });
+
+			manager.removeNode('aborted-ritual');
+
+			// Dissolution progresses past totalFrames = 60 and clears state.
+			const camera = { position: new Vector3(0, 30, 80) } as any;
+			for (let f = 0; f < 65; f++) {
+				manager.animate(f * 0.016, [node], camera);
+			}
+
+			expect(manager.meshMap.has('aborted-ritual')).toBe(false);
+
+			// And a late igniteNode call on the dead id is a safe no-op.
+			expect(() => manager.igniteNode('aborted-ritual')).not.toThrow();
+		});
+	});
 });
diff --git a/apps/dashboard/src/lib/graph/__tests__/three-mock.ts b/apps/dashboard/src/lib/graph/__tests__/three-mock.ts
index 0853560..e6afd57 100644
--- a/apps/dashboard/src/lib/graph/__tests__/three-mock.ts
+++ b/apps/dashboard/src/lib/graph/__tests__/three-mock.ts
@@ -210,6 +210,13 @@ export class Color {
 		this.b *= s;
 		return this;
 	}
+
+	setRGB(r: number, g: number, b: number) {
+		this.r = r;
+		this.g = g;
+		this.b = b;
+		return this;
+	}
 }
 
 export class BufferAttribute {
diff --git a/apps/dashboard/src/lib/stores/__tests__/toast.test.ts b/apps/dashboard/src/lib/stores/__tests__/toast.test.ts
new file mode 100644
index 0000000..3f9956f
--- /dev/null
+++ b/apps/dashboard/src/lib/stores/__tests__/toast.test.ts
@@ -0,0 +1,661 @@
+// Unit tests for the Pulse toast store (v2.2).
+//
+// The store subscribes to `eventFeed` from `$stores/websocket` at IMPORT
+// TIME, so every test re-imports the module via `vi.resetModules()` +
+// dynamic import to get a fresh `lastSeen` / `nextId` / `lastConnectionAt`
+// / dwell-timer registry. Without this, the module-level state leaks
+// between tests (especially the 1500ms ConnectionDiscovered throttle).
+//
+// The eventFeed is mocked as a plain writable<VestigeEvent[]> — we push
+// arrays directly, mirroring the way the real websocket store prepends
+// new events at index 0.
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { writable, get, type Writable } from 'svelte/store';
+import type { VestigeEvent } from '$types';
+
+// The mock `eventFeed` is hoisted so vi.mock can reference it.
+const mockEventFeed: Writable<VestigeEvent[]> = writable<VestigeEvent[]>([]);
+
+vi.mock('$stores/websocket', () => ({
+	eventFeed: mockEventFeed,
+}));
+
+// Helper — make a fresh VestigeEvent with a unique object identity.
+// The store uses reference equality (e === lastSeen) to detect freshness,
+// so every emission must be a distinct object.
+function makeEvent<T extends VestigeEvent['type']>(
+	type: T,
+	data: Record<string, unknown> = {},
+): VestigeEvent {
+	return { type, data };
+}
+
+// Prepend events onto the feed — mirrors the real websocket store, which
+// does `[parsed, ...events].slice(0, 200)`. Pass a single event or an
+// array (oldest-last, so `push([newest, older, oldest])` is the shape
+// the real subscriber sees).
+function emit(events: VestigeEvent | VestigeEvent[]) {
+	const arr = Array.isArray(events) ? events : [events];
+	mockEventFeed.update((prev) => [...arr, ...prev]);
+}
+
+// Reset the feed between tests. Combined with vi.resetModules() this
+// guarantees each test starts with a virgin toast store.
+function resetFeed() {
+	mockEventFeed.set([]);
+}
+
+// Dynamically import the toast store after resetModules so we get a
+// fresh subscription + fresh module-level state every test.
+async function loadToastStore() {
+	const mod = await import('../toast');
+	return mod;
+}
+
+describe('toast store', () => {
+	beforeEach(() => {
+		vi.useFakeTimers();
+		resetFeed();
+		vi.resetModules();
+	});
+
+	afterEach(() => {
+		vi.useRealTimers();
+	});
+
+	// ---------------------------------------------------------------
+	// Identity-based batch walk (silent-lobotomy fix)
+	// ---------------------------------------------------------------
+	describe('identity-based batch walk', () => {
+		it('processes ALL events when multiple land in one tick, not just the newest', async () => {
+			const { toasts } = await loadToastStore();
+
+			const e1 = makeEvent('DreamCompleted', {
+				memories_replayed: 3,
+				connections_found: 1,
+				insights_generated: 0,
+				duration_ms: 500,
+			});
+			const e2 = makeEvent('ConnectionDiscovered', {
+				connection_type: 'semantic',
+				weight: 0.8,
+			});
+			const e3 = makeEvent('MemoryPromoted', { new_retention: 0.9 });
+
+			// All three land in the same tick — emit as a single array
+			// (oldest-last, matching the real store prepend order).
+			emit([e3, e2, e1]);
+
+			const list = get(toasts);
+			expect(list.length).toBe(3);
+			// Queue is newest-first (store prepends): [e3, e2, e1]
+			expect(list[0].type).toBe('MemoryPromoted');
+			expect(list[1].type).toBe('ConnectionDiscovered');
+			expect(list[2].type).toBe('DreamCompleted');
+		});
+
+		it('processes events in OLDEST-first narrative order (DreamCompleted before ConnectionDiscovered)', async () => {
+			const { toasts } = await loadToastStore();
+
+			const dream = makeEvent('DreamCompleted', {
+				memories_replayed: 10,
+				connections_found: 2,
+				insights_generated: 1,
+				duration_ms: 800,
+			});
+			const bridge = makeEvent('ConnectionDiscovered', {
+				connection_type: 'causal',
+				weight: 0.75,
+			});
+
+			// dream is older, bridge is newer → emit [bridge, dream]
+			emit([bridge, dream]);
+
+			const list = get(toasts);
+			// IDs are assigned sequentially as events are processed. Dream
+			// gets processed first (oldest-first walk) → id=1. Bridge → id=2.
+			// Store prepends, so the queue is [bridge(2), dream(1)].
+			expect(list[0].id).toBeGreaterThan(list[1].id);
+			expect(list[1].type).toBe('DreamCompleted');
+			expect(list[0].type).toBe('ConnectionDiscovered');
+		});
+
+		it('does not duplicate toasts when the subscriber re-fires with no new events', async () => {
+			const { toasts } = await loadToastStore();
+
+			const e = makeEvent('MemoryPromoted', { new_retention: 0.85 });
+			emit(e);
+			expect(get(toasts).length).toBe(1);
+
+			// Re-setting the same array (no new events) must NOT produce a
+			// second toast. Also pushing an unrelated no-op update.
+			mockEventFeed.update((prev) => [...prev]);
+			expect(get(toasts).length).toBe(1);
+		});
+
+		it('handles empty feed updates gracefully (no toasts created)', async () => {
+			const { toasts } = await loadToastStore();
+
+			// Force the subscriber to fire with an empty array.
+			mockEventFeed.set([]);
+			expect(get(toasts).length).toBe(0);
+		});
+
+		it('falls back gracefully when lastSeen is evicted from the capped feed', async () => {
+			const { toasts } = await loadToastStore();
+
+			// Emit a first event that becomes lastSeen.
+			const first = makeEvent('MemoryPromoted', { new_retention: 0.8 });
+			emit(first);
+			expect(get(toasts).length).toBe(1);
+
+			// Now emit a burst where the old lastSeen is pushed out. Since
+			// we can never match it by identity, the walk goes to the end
+			// of the array and translates everything.
+			const burst = [
+				makeEvent('MemoryPromoted', { new_retention: 0.81 }),
+				makeEvent('MemoryPromoted', { new_retention: 0.82 }),
+				makeEvent('MemoryPromoted', { new_retention: 0.83 }),
+			];
+			// Replace the feed entirely — the old `first` event is gone.
+			mockEventFeed.set(burst);
+
+			// All three new events get translated. Plus the one we already had.
+			expect(get(toasts).length).toBe(4);
+		});
+	});
+
+	// ---------------------------------------------------------------
+	// Event translation — one test per meaningful type
+	// ---------------------------------------------------------------
+	describe('event translation', () => {
+		it('DreamCompleted → title + body with replayed/connections/insights/duration', async () => {
+			const { toasts } = await loadToastStore();
+
+			emit(
+				makeEvent('DreamCompleted', {
+					memories_replayed: 127,
+					connections_found: 43,
+					insights_generated: 5,
+					duration_ms: 2400,
+				}),
+			);
+
+			const t = get(toasts)[0];
+			expect(t.title).toBe('Dream consolidated');
+			expect(t.body).toContain('Replayed 127 memories');
+			expect(t.body).toContain('43 new connections');
+			expect(t.body).toContain('5 insights');
+			expect(t.body).toContain('2.4s');
+		});
+
+		it('DreamCompleted → singular grammar when replayed === 1 and found === 1', async () => {
+			const { toasts } = await loadToastStore();
+
+			emit(
+				makeEvent('DreamCompleted', {
+					memories_replayed: 1,
+					connections_found: 1,
+					insights_generated: 1,
+					duration_ms: 300,
+				}),
+			);
+
+			const t = get(toasts)[0];
+			expect(t.body).toContain('Replayed 1 memory');
+			expect(t.body).toContain('1 new connection');
+			expect(t.body).not.toContain('1 new connections');
+			expect(t.body).toContain('1 insight');
+		});
+
+		it('ConsolidationCompleted → title + body with nodes/decay/embedded/duration', async () => {
+			const { toasts } = await loadToastStore();
+
+			emit(
+				makeEvent('ConsolidationCompleted', {
+					nodes_processed: 892,
+					decay_applied: 156,
+					embeddings_generated: 48,
+					duration_ms: 1100,
+				}),
+			);
+
+			const t = get(toasts)[0];
+			expect(t.title).toBe('Consolidation swept');
+			expect(t.body).toContain('892 nodes');
+			expect(t.body).toContain('156 decayed');
+			expect(t.body).toContain('48 embedded');
+			expect(t.body).toContain('1.1s');
+		});
+
+		it('ConnectionDiscovered → title + connection type + weight', async () => {
+			const { toasts } = await loadToastStore();
+
+			emit(
+				makeEvent('ConnectionDiscovered', {
+					connection_type: 'semantic',
+					weight: 0.87,
+				}),
+			);
+
+			const t = get(toasts)[0];
+			expect(t.title).toBe('Bridge discovered');
+			expect(t.body).toContain('semantic');
+			expect(t.body).toContain('0.87');
+		});
+
+		it('MemoryPromoted → body includes retention %', async () => {
+			const { toasts } = await loadToastStore();
+
+			emit(makeEvent('MemoryPromoted', { new_retention: 0.85 }));
+
+			const t = get(toasts)[0];
+			expect(t.title).toBe('Memory promoted');
+			expect(t.body).toBe('retention 85%');
+		});
+
+		it('MemoryDemoted → body includes retention %', async () => {
+			const { toasts } = await loadToastStore();
+
+			emit(makeEvent('MemoryDemoted', { new_retention: 0.42 }));
+
+			const t = get(toasts)[0];
+			expect(t.title).toBe('Memory demoted');
+			expect(t.body).toBe('retention 42%');
+		});
+
+		it('MemorySuppressed (cascade=0) → suppression # only', async () => {
+			const { toasts } = await loadToastStore();
+
+			emit(
+				makeEvent('MemorySuppressed', {
+					suppression_count: 3,
+					estimated_cascade: 0,
+				}),
+			);
+
+			const t = get(toasts)[0];
+			expect(t.title).toBe('Forgetting');
+			expect(t.body).toBe('suppression #3');
+			expect(t.body).not.toContain('Rac1');
+		});
+
+		it('MemorySuppressed (cascade>0) → suppression # + Rac1 cascade mention', async () => {
+			const { toasts } = await loadToastStore();
+
+			emit(
+				makeEvent('MemorySuppressed', {
+					suppression_count: 2,
+					estimated_cascade: 8,
+				}),
+			);
+
+			const t = get(toasts)[0];
+			expect(t.body).toContain('suppression #2');
+			expect(t.body).toContain('Rac1 cascade');
+			expect(t.body).toContain('~8 neighbors');
+		});
+
+		it('MemoryUnsuppressed (remaining>0) → remaining count', async () => {
+			const { toasts } = await loadToastStore();
+
+			emit(makeEvent('MemoryUnsuppressed', { remaining_count: 2 }));
+
+			const t = get(toasts)[0];
+			expect(t.title).toBe('Recovered');
+			expect(t.body).toContain('2 suppressions remain');
+		});
+
+		it('MemoryUnsuppressed (remaining=0) → "fully unsuppressed"', async () => {
+			const { toasts } = await loadToastStore();
+
+			emit(makeEvent('MemoryUnsuppressed', { remaining_count: 0 }));
+
+			const t = get(toasts)[0];
+			expect(t.body).toBe('fully unsuppressed');
+		});
+
+		it('Rac1CascadeSwept → seeds + neighbors affected', async () => {
+			const { toasts } = await loadToastStore();
+
+			emit(
+				makeEvent('Rac1CascadeSwept', {
+					seeds: 3,
+					neighbors_affected: 14,
+				}),
+			);
+
+			const t = get(toasts)[0];
+			expect(t.title).toBe('Rac1 cascade');
+			expect(t.body).toContain('3 seeds');
+			expect(t.body).toContain('14 dendritic spines');
+			expect(t.body).toContain('pruned');
+		});
+
+		it('MemoryDeleted → body is id truncated to first 8 chars', async () => {
+			const { toasts } = await loadToastStore();
+
+			emit(
+				makeEvent('MemoryDeleted', {
+					id: 'deadbeefcafef00d1234567890abcdef',
+				}),
+			);
+
+			const t = get(toasts)[0];
+			expect(t.title).toBe('Memory deleted');
+			expect(t.body).toBe('deadbeef');
+		});
+
+		it.each([
+			['Heartbeat'],
+			['SearchPerformed'],
+			['RetentionDecayed'],
+			['ActivationSpread'],
+			['ImportanceScored'],
+			['MemoryCreated'],
+			['MemoryUpdated'],
+			['DreamStarted'],
+			['DreamProgress'],
+			['ConsolidationStarted'],
+			['Connected'],
+		] as const)('noise event %s produces no toast', async ([type]) => {
+			const { toasts } = await loadToastStore();
+
+			emit(makeEvent(type as VestigeEvent['type'], {}));
+
+			expect(get(toasts).length).toBe(0);
+		});
+	});
+
+	// ---------------------------------------------------------------
+	// ConnectionDiscovered throttle
+	// ---------------------------------------------------------------
+	describe('ConnectionDiscovered throttle', () => {
+		it('two ConnectionDiscovered within 1500ms → only one toast', async () => {
+			const { toasts } = await loadToastStore();
+
+			emit(
+				makeEvent('ConnectionDiscovered', {
+					connection_type: 'semantic',
+					weight: 0.8,
+				}),
+			);
+			expect(get(toasts).length).toBe(1);
+
+			// 500ms later — still inside throttle
+			vi.advanceTimersByTime(500);
+
+			emit(
+				makeEvent('ConnectionDiscovered', {
+					connection_type: 'causal',
+					weight: 0.9,
+				}),
+			);
+
+			expect(get(toasts).length).toBe(1);
+		});
+
+		it('two ConnectionDiscovered more than 1500ms apart → both toasts', async () => {
+			const { toasts } = await loadToastStore();
+
+			emit(
+				makeEvent('ConnectionDiscovered', {
+					connection_type: 'semantic',
+					weight: 0.8,
+				}),
+			);
+			expect(get(toasts).length).toBe(1);
+
+			// Wait past the throttle window (1500ms).
+			vi.advanceTimersByTime(1600);
+
+			emit(
+				makeEvent('ConnectionDiscovered', {
+					connection_type: 'causal',
+					weight: 0.9,
+				}),
+			);
+
+			expect(get(toasts).length).toBe(2);
+		});
+	});
+
+	// ---------------------------------------------------------------
+	// Hover-panic — pauseDwell / resumeDwell
+	// ---------------------------------------------------------------
+	describe('hover-panic (pauseDwell / resumeDwell)', () => {
+		it('auto-dismiss fires after dwellMs when not paused', async () => {
+			const { toasts } = await loadToastStore();
+
+			emit(makeEvent('MemoryPromoted', { new_retention: 0.8 }));
+			const t = get(toasts)[0];
+			expect(t).toBeDefined();
+			expect(t.dwellMs).toBe(4500);
+
+			// Advance just past the dwell — toast should be gone.
+			vi.advanceTimersByTime(4600);
+			expect(get(toasts).length).toBe(0);
+		});
+
+		it('pauseDwell stops the auto-dismiss — toast survives past natural dwellMs', async () => {
+			const { toasts } = await loadToastStore();
+
+			emit(makeEvent('MemoryPromoted', { new_retention: 0.8 }));
+			const t = get(toasts)[0];
+
+			// 1 second in, pause.
+			vi.advanceTimersByTime(1000);
+			toasts.pauseDwell(t.id, t.dwellMs);
+
+			// Advance WAY past the natural dwell — still there.
+			vi.advanceTimersByTime(10_000);
+			expect(get(toasts).length).toBe(1);
+			expect(get(toasts)[0].id).toBe(t.id);
+		});
+
+		it('resumeDwell schedules dismissal for the REMAINING time, not the full dwellMs', async () => {
+			const { toasts } = await loadToastStore();
+
+			emit(makeEvent('MemoryPromoted', { new_retention: 0.8 }));
+			const t = get(toasts)[0];
+			expect(t.dwellMs).toBe(4500);
+
+			// 1 second elapsed — pause. Remaining should be ~3500ms.
+			vi.advanceTimersByTime(1000);
+			toasts.pauseDwell(t.id, t.dwellMs);
+
+			// Hold paused for 10s (irrelevant to remaining calc).
+			vi.advanceTimersByTime(10_000);
+
+			// Resume — remaining is ~3500ms.
+			toasts.resumeDwell(t.id);
+
+			// At 3400ms still alive (just under remaining).
+			vi.advanceTimersByTime(3400);
+			expect(get(toasts).length).toBe(1);
+
+			// At 3500ms+, dismissed.
+			vi.advanceTimersByTime(200);
+			expect(get(toasts).length).toBe(0);
+		});
+
+		it('double-pause is a safe no-op (second call does not corrupt remaining)', async () => {
+			const { toasts } = await loadToastStore();
+
+			emit(makeEvent('MemoryPromoted', { new_retention: 0.8 }));
+			const t = get(toasts)[0];
+
+			vi.advanceTimersByTime(500);
+			toasts.pauseDwell(t.id, t.dwellMs);
+
+			// Second pause should not throw or mutate state badly. The
+			// implementation bails early because dwellTimers no longer
+			// contains the id.
+			expect(() => toasts.pauseDwell(t.id, t.dwellMs)).not.toThrow();
+
+			// Still paused — advancing doesn't dismiss.
+			vi.advanceTimersByTime(10_000);
+			expect(get(toasts).length).toBe(1);
+		});
+
+		it('dismiss while paused clears the paused state (no zombie timer)', async () => {
+			const { toasts } = await loadToastStore();
+
+			emit(makeEvent('MemoryPromoted', { new_retention: 0.8 }));
+			const t = get(toasts)[0];
+
+			vi.advanceTimersByTime(500);
+			toasts.pauseDwell(t.id, t.dwellMs);
+
+			// Programmatic dismiss.
+			toasts.dismiss(t.id);
+			expect(get(toasts).length).toBe(0);
+
+			// A later resume should be a no-op (no zombie re-schedule).
+			toasts.resumeDwell(t.id);
+			vi.advanceTimersByTime(10_000);
+			expect(get(toasts).length).toBe(0);
+		});
+
+		it('resumeDwell on a non-paused id is a no-op', async () => {
+			const { toasts } = await loadToastStore();
+
+			emit(makeEvent('MemoryPromoted', { new_retention: 0.8 }));
+			const t = get(toasts)[0];
+
+			// Without pausing — resume is a no-op and must not schedule
+			// anything new. The original timer is still ticking.
+			toasts.resumeDwell(t.id);
+
+			vi.advanceTimersByTime(4600);
+			expect(get(toasts).length).toBe(0);
+		});
+	});
+
+	// ---------------------------------------------------------------
+	// Queue behavior
+	// ---------------------------------------------------------------
+	describe('queue behavior', () => {
+		it('MAX_VISIBLE=4: creating a 5th toast evicts the oldest', async () => {
+			const { toasts } = await loadToastStore();
+
+			// Use MemoryPromoted (not throttled) to stack 5 toasts.
+			for (let i = 0; i < 5; i++) {
+				emit(makeEvent('MemoryPromoted', { new_retention: 0.5 + i * 0.01 }));
+				// Small advance so each event has a distinct identity and no batch-merge.
+				vi.advanceTimersByTime(10);
+			}
+
+			const list = get(toasts);
+			expect(list.length).toBe(4);
+
+			// IDs are assigned 1..5 in event-processing order. Store prepends,
+			// so the queue is [id=5, id=4, id=3, id=2]; id=1 was evicted.
+			const ids = list.map((t) => t.id);
+			expect(ids).not.toContain(1);
+			expect(ids).toContain(5);
+		});
+
+		it('clear() dismisses all toasts and cancels all timers', async () => {
+			const { toasts } = await loadToastStore();
+
+			emit([
+				makeEvent('MemoryPromoted', { new_retention: 0.8 }),
+				makeEvent('MemoryDemoted', { new_retention: 0.4 }),
+			]);
+			expect(get(toasts).length).toBe(2);
+
+			toasts.clear();
+			expect(get(toasts).length).toBe(0);
+
+			// Advancing past the dwell must not re-fire anything (no zombie timers).
+			vi.advanceTimersByTime(10_000);
+			expect(get(toasts).length).toBe(0);
+		});
+
+		it('dismissing a specific id leaves the other toasts intact', async () => {
+			const { toasts } = await loadToastStore();
+
+			emit(makeEvent('MemoryPromoted', { new_retention: 0.8 }));
+			vi.advanceTimersByTime(10);
+			emit(makeEvent('MemoryDemoted', { new_retention: 0.4 }));
+
+			const list = get(toasts);
+			expect(list.length).toBe(2);
+			const firstId = list[list.length - 1].id; // oldest
+
+			toasts.dismiss(firstId);
+
+			const remaining = get(toasts);
+			expect(remaining.length).toBe(1);
+			expect(remaining[0].id).not.toBe(firstId);
+		});
+	});
+
+	// ---------------------------------------------------------------
+	// Demo sequence
+	// ---------------------------------------------------------------
+	describe('fireDemoSequence', () => {
+		it('schedules 4 toasts staggered by 800ms', async () => {
+			const { toasts, fireDemoSequence } = await loadToastStore();
+
+			fireDemoSequence();
+
+			// t=0: nothing yet (all are setTimeout, even the first at i=0 * 800 = 0ms).
+			// setTimeout(_, 0) still goes to the next tick under fake timers.
+			expect(get(toasts).length).toBe(0);
+
+			// Flush i=0.
+			vi.advanceTimersByTime(1);
+			expect(get(toasts).length).toBe(1);
+			expect(get(toasts)[0].type).toBe('DreamCompleted');
+
+			// i=1 at 800ms.
+			vi.advanceTimersByTime(800);
+			expect(get(toasts).length).toBe(2);
+			expect(get(toasts)[0].type).toBe('ConnectionDiscovered');
+
+			// i=2 at 1600ms.
+			vi.advanceTimersByTime(800);
+			expect(get(toasts).length).toBe(3);
+			expect(get(toasts)[0].type).toBe('MemorySuppressed');
+
+			// i=3 at 2400ms.
+			vi.advanceTimersByTime(800);
+			expect(get(toasts).length).toBe(4);
+			expect(get(toasts)[0].type).toBe('ConsolidationCompleted');
+		});
+	});
+
+	// ---------------------------------------------------------------
+	// Toast shape sanity
+	// ---------------------------------------------------------------
+	describe('toast shape', () => {
+		it('each toast has id, createdAt, color, dwellMs fields populated', async () => {
+			const { toasts } = await loadToastStore();
+
+			emit(makeEvent('MemoryPromoted', { new_retention: 0.9 }));
+
+			const t = get(toasts)[0];
+			expect(t.id).toBeTypeOf('number');
+			expect(t.createdAt).toBeTypeOf('number');
+			expect(t.color).toBeTypeOf('string');
+			expect(t.dwellMs).toBeTypeOf('number');
+			expect(t.color.length).toBeGreaterThan(0);
+		});
+
+		it('ids are strictly increasing across successive toasts', async () => {
+			const { toasts } = await loadToastStore();
+
+			emit(makeEvent('MemoryPromoted', { new_retention: 0.9 }));
+			vi.advanceTimersByTime(10);
+			emit(makeEvent('MemoryDemoted', { new_retention: 0.3 }));
+
+			const list = get(toasts);
+			expect(list.length).toBe(2);
+			// Store prepends, so list[0] is newer = higher id.
+			expect(list[0].id).toBeGreaterThan(list[1].id);
+		});
+	});
+});
diff --git a/apps/dashboard/src/lib/stores/__tests__/websocket.test.ts b/apps/dashboard/src/lib/stores/__tests__/websocket.test.ts
new file mode 100644
index 0000000..b42a887
--- /dev/null
+++ b/apps/dashboard/src/lib/stores/__tests__/websocket.test.ts
@@ -0,0 +1,341 @@
+/**
+ * Unit tests for the websocket store.
+ *
+ * Scope: pure-store methods and derived-store behavior that can be tested
+ * without a real WebSocket connection. Connection lifecycle, reconnect
+ * backoff, and live handler wiring are out of scope — those are integration
+ * concerns.
+ */
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { get } from 'svelte/store';
+
+// Stub the global WebSocket BEFORE importing the store, so any accidental
+// `connect()` path does not attempt a real network call and does not throw.
+// The FakeWS also captures the most-recently-constructed instance so tests
+// that want to drive `onmessage` (to exercise the Heartbeat branch of the
+// internal update handler) can do so.
+class FakeWS {
+	static last: FakeWS | null = null;
+	static OPEN = 1;
+	readyState = 0;
+	onopen: ((ev?: unknown) => void) | null = null;
+	onclose: ((ev?: unknown) => void) | null = null;
+	onmessage: ((ev: { data: string }) => void) | null = null;
+	onerror: ((ev?: unknown) => void) | null = null;
+	constructor(public url: string) {
+		FakeWS.last = this;
+	}
+	close() {
+		/* no-op */
+	}
+	addEventListener() {
+		/* no-op */
+	}
+	removeEventListener() {
+		/* no-op */
+	}
+}
+vi.stubGlobal('WebSocket', FakeWS);
+
+import {
+	websocket,
+	eventFeed,
+	isConnected,
+	memoryCount,
+	avgRetention,
+	suppressedCount,
+	uptimeSeconds,
+	heartbeat,
+	formatUptime,
+} from '../websocket';
+import type { VestigeEvent } from '$types';
+
+const MAX_EVENTS = 200;
+
+function makeEvent(
+	type: VestigeEvent['type'] = 'MemoryCreated',
+	data: Record<string, unknown> = {}
+): VestigeEvent {
+	return { type, data };
+}
+
+function makeHeartbeat(data: Record<string, unknown> = {}): VestigeEvent {
+	return {
+		type: 'Heartbeat',
+		data: {
+			memory_count: 0,
+			avg_retention: 0,
+			suppressed_count: 0,
+			uptime_secs: 0,
+			...data,
+		},
+	};
+}
+
+/**
+ * Helper: drive a heartbeat into the store via the internal onmessage path.
+ * We cannot reach `update()` directly, and `injectEvent()` deliberately
+ * does NOT treat heartbeats specially, so the only way to populate
+ * `lastHeartbeat` is to route through the WebSocket handler.
+ */
+function deliverHeartbeat(hb: VestigeEvent) {
+	// Disconnect to reset any prior state, then connect to install handlers
+	// on a fresh FakeWS instance whose onmessage we can invoke.
+	websocket.disconnect();
+	websocket.connect('ws://test.invalid/ws');
+	const ws = FakeWS.last;
+	if (!ws || !ws.onmessage) throw new Error('FakeWS onmessage not wired');
+	ws.onmessage({ data: JSON.stringify(hb) });
+}
+
+beforeEach(() => {
+	// Reset the events array between tests; lastHeartbeat is explicitly left
+	// alone here because `clearEvents()` preserves it (that is itself tested
+	// below). For the derived-store defaults tests we call disconnect() to
+	// fully reset the store.
+	websocket.clearEvents();
+});
+
+// ---------------------------------------------------------------------------
+// injectEvent
+// ---------------------------------------------------------------------------
+
+describe('injectEvent', () => {
+	it('adds a single event at index 0', () => {
+		const evt = makeEvent('MemoryCreated', { id: 'a' });
+		websocket.injectEvent(evt);
+		const feed = get(eventFeed);
+		expect(feed.length).toBe(1);
+		expect(feed[0]).toEqual(evt);
+	});
+
+	it('prepends: newest injected ends up at index 0', () => {
+		const first = makeEvent('MemoryCreated', { id: 'first' });
+		const second = makeEvent('MemoryUpdated', { id: 'second' });
+		const third = makeEvent('MemoryDeleted', { id: 'third' });
+		websocket.injectEvent(first);
+		websocket.injectEvent(second);
+		websocket.injectEvent(third);
+		const feed = get(eventFeed);
+		expect(feed.length).toBe(3);
+		expect(feed[0]).toEqual(third);
+		expect(feed[1]).toEqual(second);
+		expect(feed[2]).toEqual(first);
+	});
+
+	it('caps the events array at MAX_EVENTS (200)', () => {
+		for (let i = 0; i < MAX_EVENTS + 50; i++) {
+			websocket.injectEvent(makeEvent('MemoryCreated', { seq: i }));
+		}
+		const feed = get(eventFeed);
+		expect(feed.length).toBe(MAX_EVENTS);
+	});
+
+	it('evicts the oldest entry when at capacity (FIFO drop)', () => {
+		// Fill to exactly capacity, then push one more: seq=0 should be gone.
+		for (let i = 0; i < MAX_EVENTS; i++) {
+			websocket.injectEvent(makeEvent('MemoryCreated', { seq: i }));
+		}
+		websocket.injectEvent(makeEvent('MemoryCreated', { seq: 999 }));
+		const feed = get(eventFeed);
+		expect(feed.length).toBe(MAX_EVENTS);
+		expect(feed[0].data.seq).toBe(999);
+		// Oldest (seq=0) evicted; tail is now the prior second-oldest (seq=1).
+		expect(feed[feed.length - 1].data.seq).toBe(1);
+		expect(feed.some((e) => e.data.seq === 0)).toBe(false);
+	});
+
+	it('triggers the eventFeed derived store to emit on each injection', () => {
+		const observed: number[] = [];
+		const unsub = eventFeed.subscribe((events) => {
+			observed.push(events.length);
+		});
+		// Initial subscription fires once with current length (0 after beforeEach).
+		const initialEmitCount = observed.length;
+		websocket.injectEvent(makeEvent());
+		websocket.injectEvent(makeEvent());
+		unsub();
+		// Two injections should produce two additional emits beyond the initial one.
+		expect(observed.length).toBe(initialEmitCount + 2);
+		expect(observed[observed.length - 1]).toBe(2);
+	});
+
+	it('does NOT treat Heartbeat-typed events specially when injected', () => {
+		// Documented behavior: injectEvent is a raw prepend. Only the real
+		// onmessage handler branches on type === 'Heartbeat'. If a caller
+		// injects a Heartbeat, it lands in the events array, and lastHeartbeat
+		// is untouched. Callers who want a heartbeat-like derived-store update
+		// must route through the WebSocket handler instead.
+		websocket.disconnect(); // reset lastHeartbeat to null
+		const hb = makeHeartbeat({ memory_count: 42 });
+		websocket.injectEvent(hb);
+		const feed = get(eventFeed);
+		expect(feed.length).toBe(1);
+		expect(feed[0]).toEqual(hb);
+		// memoryCount still 0 because lastHeartbeat was never written.
+		expect(get(memoryCount)).toBe(0);
+		expect(get(heartbeat)).toBeNull();
+	});
+});
+
+// ---------------------------------------------------------------------------
+// Derived store defaults (no heartbeat yet)
+// ---------------------------------------------------------------------------
+
+describe('derived stores — defaults with no heartbeat', () => {
+	beforeEach(() => {
+		// Full reset so lastHeartbeat is null.
+		websocket.disconnect();
+	});
+
+	it('isConnected is false after disconnect', () => {
+		expect(get(isConnected)).toBe(false);
+	});
+
+	it('heartbeat is null when no heartbeat has arrived', () => {
+		expect(get(heartbeat)).toBeNull();
+	});
+
+	it('memoryCount returns 0 when no heartbeat has arrived', () => {
+		expect(get(memoryCount)).toBe(0);
+	});
+
+	it('avgRetention returns 0 when no heartbeat has arrived', () => {
+		expect(get(avgRetention)).toBe(0);
+	});
+
+	it('suppressedCount returns 0 when no heartbeat has arrived', () => {
+		expect(get(suppressedCount)).toBe(0);
+	});
+
+	it('uptimeSeconds returns 0 when no heartbeat has arrived', () => {
+		expect(get(uptimeSeconds)).toBe(0);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// Derived stores after heartbeat
+// ---------------------------------------------------------------------------
+
+describe('derived stores — after heartbeat delivery', () => {
+	it('memoryCount, avgRetention, suppressedCount, uptimeSeconds all update', () => {
+		deliverHeartbeat(
+			makeHeartbeat({
+				memory_count: 123,
+				avg_retention: 0.74,
+				suppressed_count: 5,
+				uptime_secs: 3661,
+			})
+		);
+		expect(get(memoryCount)).toBe(123);
+		expect(get(avgRetention)).toBeCloseTo(0.74);
+		expect(get(suppressedCount)).toBe(5);
+		expect(get(uptimeSeconds)).toBe(3661);
+		const hb = get(heartbeat);
+		expect(hb).not.toBeNull();
+		expect(hb?.type).toBe('Heartbeat');
+	});
+
+	it('heartbeat events do NOT enter the events array (handled by onmessage)', () => {
+		websocket.disconnect();
+		deliverHeartbeat(makeHeartbeat({ memory_count: 1 }));
+		expect(get(eventFeed).length).toBe(0);
+	});
+
+	it('non-heartbeat events delivered via onmessage enter the events array', () => {
+		websocket.disconnect();
+		websocket.connect('ws://test.invalid/ws');
+		const ws = FakeWS.last!;
+		ws.onmessage!({ data: JSON.stringify(makeEvent('MemoryCreated', { id: 'x' })) });
+		const feed = get(eventFeed);
+		expect(feed.length).toBe(1);
+		expect(feed[0].type).toBe('MemoryCreated');
+	});
+});
+
+// ---------------------------------------------------------------------------
+// clearEvents
+// ---------------------------------------------------------------------------
+
+describe('clearEvents', () => {
+	it('empties the events array', () => {
+		websocket.injectEvent(makeEvent());
+		websocket.injectEvent(makeEvent());
+		expect(get(eventFeed).length).toBe(2);
+		websocket.clearEvents();
+		expect(get(eventFeed).length).toBe(0);
+	});
+
+	it('preserves lastHeartbeat (does NOT clear it)', () => {
+		deliverHeartbeat(makeHeartbeat({ memory_count: 77 }));
+		expect(get(memoryCount)).toBe(77);
+		websocket.injectEvent(makeEvent('MemoryCreated'));
+		websocket.clearEvents();
+		expect(get(eventFeed).length).toBe(0);
+		// lastHeartbeat untouched, so memoryCount still reflects the heartbeat.
+		expect(get(memoryCount)).toBe(77);
+		expect(get(heartbeat)).not.toBeNull();
+	});
+});
+
+// ---------------------------------------------------------------------------
+// formatUptime
+// ---------------------------------------------------------------------------
+
+describe('formatUptime', () => {
+	it("returns '—' for negative input", () => {
+		expect(formatUptime(-1)).toBe('—');
+	});
+
+	it("returns '—' for non-finite input (NaN, Infinity)", () => {
+		expect(formatUptime(NaN)).toBe('—');
+		expect(formatUptime(Infinity)).toBe('—');
+		expect(formatUptime(-Infinity)).toBe('—');
+	});
+
+	it("returns '0s' for 0 (boundary: non-negative, all units zero)", () => {
+		// secs=0 is NOT < 0, so it falls through to the '${s}s' branch.
+		expect(formatUptime(0)).toBe('0s');
+	});
+
+	it('seconds-only branch: 47s', () => {
+		expect(formatUptime(47)).toBe('47s');
+	});
+
+	it('seconds boundary: 59s → "59s"', () => {
+		expect(formatUptime(59)).toBe('59s');
+	});
+
+	it('minute boundary: 60s → "1m" (no trailing 0s)', () => {
+		expect(formatUptime(60)).toBe('1m');
+	});
+
+	it('minutes + seconds: 190s → "3m 10s"', () => {
+		expect(formatUptime(190)).toBe('3m 10s');
+	});
+
+	it('hour boundary minus one: 3599s → "59m 59s"', () => {
+		expect(formatUptime(3599)).toBe('59m 59s');
+	});
+
+	it('hour boundary: 3600s → "1h" (no trailing 0m)', () => {
+		expect(formatUptime(3600)).toBe('1h');
+	});
+
+	it('hours + minutes: 11520s (3h 12m) → "3h 12m"', () => {
+		expect(formatUptime(3 * 3600 + 12 * 60)).toBe('3h 12m');
+	});
+
+	it('day boundary minus one: 86399s → "23h 59m"', () => {
+		// Two-most-significant-units rule: hours + minutes, seconds dropped.
+		expect(formatUptime(86399)).toBe('23h 59m');
+	});
+
+	it('day boundary: 86400s → "1d" (no trailing 0h)', () => {
+		expect(formatUptime(86400)).toBe('1d');
+	});
+
+	it('days + hours: 4d 2h → "4d 2h" (minutes dropped)', () => {
+		expect(formatUptime(4 * 86400 + 2 * 3600 + 37 * 60)).toBe('4d 2h');
+	});
+});