diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 91a60a1..6b342ea 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -55,6 +55,38 @@ jobs:
       - name: Generate the third-party license file
         run: bun scripts/generate-third-party-licenses.ts --out "$RUNNER_TEMP/THIRD_PARTY_LICENSES.txt" --target x86_64-unknown-linux-gnu
 
+  e2e:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
+        with:
+          persist-credentials: false
+      - uses: oven-sh/setup-bun@0c5077e51419868618aeaa5fe8019c62421857d6 # v2.2.0
+        with: { bun-version: 1.3.14 }
+      - uses: dtolnay/rust-toolchain@6bed0761d98439e5a578e2877258200ad565ba87 # stable
+        with: { toolchain: '1.91', targets: wasm32-unknown-unknown }
+      - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2
+      - uses: taiki-e/install-action@76c2e6406e52637deed7160d77bded76bd83e06e # v2.87.14
+        with: { tool: wasm-bindgen-cli@0.2.127 }
+      - uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
+        with:
+          path: ~/.bun/install/cache
+          key: bun-${{ runner.os }}-${{ hashFiles('bun.lock') }}
+          restore-keys: bun-${{ runner.os }}-
+      - run: bun install --frozen-lockfile
+      - name: Install Chromium for Playwright
+        run: bun x playwright install --with-deps chromium
+        working-directory: apps/app
+      - name: Run end-to-end tests against the browser build
+        run: bun run --cwd apps/app test:e2e
+      - name: Keep traces of failed tests
+        if: failure()
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: e2e-traces
+          path: apps/app/test-results/
+          retention-days: 7
+
   rust:
     strategy:
       fail-fast: false
diff --git a/.gitignore b/.gitignore
index 2fededf..9cb792c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -21,3 +21,6 @@ crates/workspace-format/bindings/
 
 # Agent worktrees
 .claude/worktrees/
+# Playwright output
+test-results/
+playwright-report/
diff --git a/apps/app/package.json b/apps/app/package.json
index 663fe97..da2570f 100644
--- a/apps/app/package.json
+++ b/apps/app/package.json
@@ -8,7 +8,8 @@
 		"build": "bun run wasm:build && vite build",
 		"build:hosted": "bun run wasm:build && NOURA_HOSTED_BUILD=1 vite build",
 		"check": "bun run wasm:build && svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
-		"lint": "prettier --check src",
+		"lint": "prettier --check src tests",
+		"test:e2e": "playwright test",
 		"tauri": "tauri"
 	},
 	"dependencies": {
@@ -37,6 +38,7 @@
 		"jsdom": "30.0.1",
 		"@fontsource-variable/public-sans": "^5.3.0",
 		"@internationalized/date": "^3.12.0",
+		"@playwright/test": "1.62.1",
 		"@sveltejs/adapter-static": "latest",
 		"@sveltejs/kit": "latest",
 		"@sveltejs/vite-plugin-svelte": "latest",
diff --git a/apps/app/playwright.config.ts b/apps/app/playwright.config.ts
new file mode 100644
index 0000000..dbc0722
--- /dev/null
+++ b/apps/app/playwright.config.ts
@@ -0,0 +1,47 @@
+import { defineConfig } from '@playwright/test';
+
+const port = Number(process.env.NOURA_E2E_PORT ?? 4317);
+const baseURL = `http://localhost:${port}`;
+
+/**
+ * End-to-end tests drive the browser build of the app: the same shell,
+ * routes and editor as the desktop app, backed by the browser workspace
+ * worker and its origin-private file system. Every test gets a fresh browser
+ * context, so every test starts from an empty workspace list.
+ */
+export default defineConfig({
+	testDir: './tests/e2e',
+	testMatch: '**/*.e2e.ts',
+	fullyParallel: true,
+	forbidOnly: !!process.env.CI,
+	// One retry on CI marks a timing-sensitive test as flaky instead of failing
+	// the build; the report still lists it so it gets fixed.
+	retries: process.env.CI ? 1 : 0,
+	workers: process.env.CI ? 2 : undefined,
+	timeout: 60_000,
+	expect: { timeout: 10_000 },
+	reporter: process.env.CI ? [['list'], ['github']] : 'list',
+	use: {
+		baseURL,
+		trace: 'retain-on-failure',
+	},
+	projects: [
+		{
+			name: 'chromium',
+			// Chromium's own user agent, not a device preset: the app reads the
+			// platform to pick Cmd or Ctrl, and so does ControlOrMeta.
+			use: {
+				browserName: 'chromium',
+				viewport: { width: 1400, height: 900 },
+			},
+		},
+	],
+	webServer: {
+		command: `bun run build && bun x vite preview --port ${port} --strictPort`,
+		url: baseURL,
+		reuseExistingServer: !process.env.CI,
+		timeout: 180_000,
+		stdout: 'ignore',
+		stderr: 'pipe',
+	},
+});
diff --git a/apps/app/src/app.css b/apps/app/src/app.css
index dfb659e..a5b930b 100644
--- a/apps/app/src/app.css
+++ b/apps/app/src/app.css
@@ -36,6 +36,12 @@
 	--chart-3: oklch(0.439 0 0);
 	--chart-4: oklch(0.371 0 0);
 	--chart-5: oklch(0.269 0 0);
+	/* Code highlighting, readable on --muted in each theme. */
+	--syntax-keyword: #6f42c1;
+	--syntax-string: #116329;
+	--syntax-number: #953800;
+	--syntax-type: #0550ae;
+	--syntax-definition: #0a3069;
 	--radius: 0.625rem;
 	--sidebar: oklch(0.985 0 0);
 	--sidebar-foreground: oklch(0.145 0 0);
@@ -71,6 +77,11 @@
 	--chart-3: oklch(0.439 0 0);
 	--chart-4: oklch(0.371 0 0);
 	--chart-5: oklch(0.269 0 0);
+	--syntax-keyword: #ff7b72;
+	--syntax-string: #a5d6ff;
+	--syntax-number: #79c0ff;
+	--syntax-type: #ffa657;
+	--syntax-definition: #d2a8ff;
 	--sidebar: oklch(0.205 0 0);
 	--sidebar-foreground: oklch(0.985 0 0);
 	--sidebar-primary: oklch(0.922 0 0);
@@ -240,6 +251,7 @@
 	text-decoration: line-through;
 }
 .live-md .cm-md-checkbox {
+	position: relative;
 	display: inline-block;
 	width: 0.9rem;
 	height: 0.9rem;
@@ -250,9 +262,18 @@
 	vertical-align: text-bottom;
 }
 .live-md .cm-md-checkbox[aria-checked='true'] {
-	background: var(--primary);
+	background-color: var(--primary);
 	border-color: var(--primary);
 }
+/* The check mark takes the theme's contrast color, like the Checkbox. */
+.live-md .cm-md-checkbox[aria-checked='true']::after {
+	content: '';
+	position: absolute;
+	inset: 0;
+	background-color: var(--primary-foreground);
+	mask: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16' fill='none' stroke='black' stroke-width='2.5' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpath d='M3.5 8.5l3 3 6-7'/%3E%3C/svg%3E")
+		center / 100% 100% no-repeat;
+}
 .live-md .cm-md-image {
 	display: block;
 	padding: 0.35rem 0;
diff --git a/apps/app/src/lib/app-shortcuts.test.ts b/apps/app/src/lib/app-shortcuts.test.ts
index 35f23fb..3c20369 100644
--- a/apps/app/src/lib/app-shortcuts.test.ts
+++ b/apps/app/src/lib/app-shortcuts.test.ts
@@ -1,5 +1,20 @@
 import { expect, test } from 'bun:test';
-import { shortcutCommand, type ShortcutEvent } from './app-shortcuts';
+import {
+	shortcutCommand,
+	shortcutOnce,
+	type ShortcutEvent,
+} from './app-shortcuts';
+
+test('a menu report of the same press runs once; repeated presses all run', () => {
+	const once = shortcutOnce(300);
+	expect(once('close-tab', 'key', 0)).toBe(true);
+	expect(once('close-tab', 'menu', 10)).toBe(false);
+	expect(once('close-tab', 'key', 100)).toBe(true);
+	expect(once('close-tab', 'key', 150)).toBe(true);
+	expect(once('close-tab', 'menu', 500)).toBe(true);
+	expect(once('close-tab', 'key', 520)).toBe(false);
+	expect(once('new-note', 'menu', 530)).toBe(true);
+});
 
 function press(key: string, extra: Partial<ShortcutEvent> = {}): ShortcutEvent {
 	return {
diff --git a/apps/app/src/lib/app-shortcuts.ts b/apps/app/src/lib/app-shortcuts.ts
index ff7d632..331db6f 100644
--- a/apps/app/src/lib/app-shortcuts.ts
+++ b/apps/app/src/lib/app-shortcuts.ts
@@ -52,6 +52,26 @@ export function shortcutCommand(
 	return GO_TO[key] ?? null;
 }
 
+/** Where a command came from: a key press or the macOS menu bar. */
+export type ShortcutSource = 'key' | 'menu';
+
+/**
+ * On a Mac the menu bar and the key press can both report one shortcut.
+ * The returned check lets the second report of a pair through only when it
+ * comes from the same source, so pressing a shortcut twice quickly (Cmd-W
+ * to close two tabs) still runs it twice.
+ */
+export function shortcutOnce(windowMs = 300) {
+	const last = new Map<string, { at: number; source: ShortcutSource }>();
+	return (command: string, source: ShortcutSource, now: number): boolean => {
+		const previous = last.get(command);
+		if (previous && previous.source !== source && now - previous.at < windowMs)
+			return false;
+		last.set(command, { at: now, source });
+		return true;
+	};
+}
+
 /** Shortcuts as listed in Settings, in the order they are shown. */
 export const APP_SHORTCUTS: ReadonlyArray<{
 	label: string;
@@ -62,6 +82,7 @@ export const APP_SHORTCUTS: ReadonlyArray<{
 	{ label: 'Open a file by name', keys: ['Mod', 'O'] },
 	{ label: 'Search file contents', keys: ['Mod', 'Shift', 'F'] },
 	{ label: 'Search and run commands', keys: ['Mod', 'K'] },
+	{ label: 'Rename the open file', keys: ['F2'] },
 	{ label: 'Close tab', keys: ['Mod', 'W'] },
 	{ label: 'Next tab', keys: ['Ctrl', 'Tab'] },
 	{ label: 'Previous tab', keys: ['Ctrl', 'Shift', 'Tab'] },
diff --git a/apps/app/src/lib/command-palette.svelte.ts b/apps/app/src/lib/command-palette.svelte.ts
index cb23ae7..40983b5 100644
--- a/apps/app/src/lib/command-palette.svelte.ts
+++ b/apps/app/src/lib/command-palette.svelte.ts
@@ -12,6 +12,31 @@ type CommandPaletteMode = 'all' | 'files' | 'search';
 class CommandPaletteStore {
 	open = $state(false);
 	mode = $state<CommandPaletteMode>('all');
+	/** Where focus was before the palette opened, to return it on close. */
+	returnFocus: HTMLElement | null = null;
+	#stopTypeAhead: (() => void) | null = null;
+	/** Characters typed before the palette's field took focus. */
+	#typedAhead = '';
+	#receiver: ((text: string) => void) | null = null;
+
+	/**
+	 * The palette adds characters typed before its field had focus to its
+	 * query through `receive`, including any typed before it mounted.
+	 */
+	receiveTypedAhead(receive: (text: string) => void): () => void {
+		this.#receiver = receive;
+		this.#deliver();
+		return () => {
+			if (this.#receiver === receive) this.#receiver = null;
+		};
+	}
+
+	#deliver() {
+		if (!this.#receiver || !this.#typedAhead) return;
+		const text = this.#typedAhead;
+		this.#typedAhead = '';
+		this.#receiver(text);
+	}
 
 	toggle() {
 		if (this.open) this.close();
@@ -20,12 +45,47 @@ class CommandPaletteStore {
 
 	close() {
 		this.open = false;
+		this.#stopTypeAhead?.();
 	}
 
 	show(mode: CommandPaletteMode = 'all') {
 		this.mode = mode;
+		if (!this.open) this.#takeKeys();
 		this.open = true;
 	}
+
+	/**
+	 * The palette's field takes focus a moment after the palette opens, and
+	 * people start typing right after the shortcut. Until the field has
+	 * focus, the element that had it lets go, so those keys cannot edit the
+	 * document behind the palette, and the palette collects them instead.
+	 */
+	#takeKeys() {
+		if (typeof document === 'undefined') return;
+		this.#stopTypeAhead?.();
+		const active = document.activeElement;
+		this.returnFocus =
+			active instanceof HTMLElement && active !== document.body ? active : null;
+		this.returnFocus?.blur();
+		this.#typedAhead = '';
+		const collect = (event: KeyboardEvent) => {
+			if (event.target !== document.body) return;
+			if (event.metaKey || event.ctrlKey || event.altKey) return;
+			if (event.key.length !== 1) return;
+			event.preventDefault();
+			this.#typedAhead += event.key;
+			this.#deliver();
+		};
+		const stop = () => {
+			window.removeEventListener('keydown', collect, true);
+			document.removeEventListener('focusin', stop, true);
+			this.#stopTypeAhead = null;
+		};
+		window.addEventListener('keydown', collect, true);
+		// Once anything takes focus, keys go where they belong again.
+		document.addEventListener('focusin', stop, true);
+		this.#stopTypeAhead = stop;
+	}
 }
 
 export const commandPalette = new CommandPaletteStore();
diff --git a/apps/app/src/lib/components/app-shortcuts.svelte b/apps/app/src/lib/components/app-shortcuts.svelte
index d27be75..2912c9f 100644
--- a/apps/app/src/lib/components/app-shortcuts.svelte
+++ b/apps/app/src/lib/components/app-shortcuts.svelte
@@ -3,7 +3,11 @@
 	import { page } from '$app/state';
 	import { onMount } from 'svelte';
 	import { subscribeAppMenu, type AppMenuCommand } from '@noura/workspace';
-	import { shortcutCommand } from '$lib/app-shortcuts';
+	import {
+		shortcutCommand,
+		shortcutOnce,
+		type ShortcutSource,
+	} from '$lib/app-shortcuts';
 	import { commandPalette } from '$lib/command-palette.svelte';
 	import { createFolder, createNote } from '$lib/file-actions';
 	import { hostOs } from '$lib/host-os';
@@ -29,13 +33,11 @@
 	};
 
 	// On a Mac the menu bar and the key press can both report one shortcut;
-	// run each command once.
-	const lastRun: Partial<Record<AppMenuCommand, number>> = {};
+	// run each press once.
+	const once = shortcutOnce();
 
-	async function run(command: AppMenuCommand) {
-		const now = performance.now();
-		if (now - (lastRun[command] ?? -Infinity) < 300) return;
-		lastRun[command] = now;
+	async function run(command: AppMenuCommand, source: ShortcutSource) {
+		if (!once(command, source, performance.now())) return;
 		const path = ROUTES[command];
 		if (path) {
 			const pluginId = routePlugin(path);
@@ -81,14 +83,14 @@
 		const command = shortcutCommand(event, os);
 		if (!command) return;
 		event.preventDefault();
-		void run(command);
+		void run(command, 'key');
 	}
 
 	onMount(() => {
 		if (getAppPlatform() !== 'desktop') return;
 		let disposed = false;
 		let unsubscribe: (() => void) | undefined;
-		void subscribeAppMenu((command) => void run(command))
+		void subscribeAppMenu((command) => void run(command, 'menu'))
 			.then((stop) => {
 				if (disposed) stop();
 				else unsubscribe = stop;
diff --git a/apps/app/src/lib/components/command-palette.svelte b/apps/app/src/lib/components/command-palette.svelte
index 85dec90..584bdec 100644
--- a/apps/app/src/lib/components/command-palette.svelte
+++ b/apps/app/src/lib/components/command-palette.svelte
@@ -1,6 +1,6 @@
 <script lang="ts">
 	import { goto } from '$app/navigation';
-	import { onDestroy } from 'svelte';
+	import { onDestroy, onMount, tick } from 'svelte';
 	import { toast } from 'svelte-sonner';
 	import { getSettingsDialog } from '$lib/settings.svelte';
 	import { commandPalette } from '$lib/command-palette.svelte';
@@ -94,6 +94,24 @@
 		if (mode !== 'files') search.update(value);
 	}
 
+	let input = $state<HTMLInputElement | null>(null);
+
+	// The dialog focuses its field when it mounts. Opened again while it was
+	// still closing, it does not mount again, so focus the field here too.
+	$effect(() => {
+		if (!commandPalette.open || !input) return;
+		const field = input;
+		void tick().then(() => {
+			if (commandPalette.open && document.activeElement !== field)
+				field.focus();
+		});
+	});
+
+	// Keys typed before the field had focus start the query.
+	onMount(() =>
+		commandPalette.receiveTypedAhead((text) => setQuery(query + text)),
+	);
+
 	function close() {
 		commandPalette.close();
 		query = '';
@@ -160,6 +178,8 @@
 	}
 
 	function handleKeydown(event: KeyboardEvent) {
+		// The editor takes Cmd-K for links; a handled key is not a shortcut.
+		if (event.defaultPrevented) return;
 		if (
 			(event.metaKey || event.ctrlKey) &&
 			!event.shiftKey &&
@@ -178,7 +198,13 @@
 <Command.Dialog
 	contentProps={{
 		onCloseAutoFocus: (event) => {
-			if (settings.open) event.preventDefault();
+			// The palette released focus when it opened; give it back to where
+			// it was, unless Settings opened or the palette opened again.
+			event.preventDefault();
+			if (settings.open || commandPalette.open) return;
+			const previous = commandPalette.returnFocus;
+			commandPalette.returnFocus = null;
+			if (previous?.isConnected) previous.focus();
 		},
 	}}
 	bind:open={
@@ -193,7 +219,11 @@
 	description="Open files, search the workspace, or create something"
 	class="max-w-xl"
 >
-	<Command.Input bind:value={() => query, setQuery} {placeholder} />
+	<Command.Input
+		bind:ref={input}
+		bind:value={() => query, setQuery}
+		{placeholder}
+	/>
 	<Command.List
 		{@attach () => {
 			// Quick open needs the file list even before the tree was shown.
diff --git a/apps/app/src/lib/components/document-header.svelte b/apps/app/src/lib/components/document-header.svelte
index d9df0fa..2882fa4 100644
--- a/apps/app/src/lib/components/document-header.svelte
+++ b/apps/app/src/lib/components/document-header.svelte
@@ -62,13 +62,52 @@
 		}
 	}
 
+	let nameField: HTMLInputElement | null = null;
+
 	function focusName(input: HTMLInputElement) {
+		nameField = input;
 		if (!autofocus) return;
 		input.focus();
 		input.select();
 	}
+
+	/**
+	 * F2 renames the open document from anywhere, including its text: a
+	 * click in the file tree opens the file and puts the caret in the text,
+	 * where the tree's own F2 no longer applies. Other text fields and
+	 * dialogs keep the key.
+	 */
+	function renameShortcut(event: KeyboardEvent) {
+		if (
+			event.key !== 'F2' ||
+			event.defaultPrevented ||
+			event.metaKey ||
+			event.ctrlKey ||
+			event.altKey ||
+			event.shiftKey
+		)
+			return;
+		const field = nameField;
+		if (!field || field.disabled) return;
+		const target = event.target instanceof HTMLElement ? event.target : null;
+		const inText = target?.closest('.cm-editor') !== null;
+		if (
+			target &&
+			!inText &&
+			(target.closest('[role="dialog"], [role="alertdialog"]') ||
+				target instanceof HTMLInputElement ||
+				target instanceof HTMLTextAreaElement ||
+				target.isContentEditable)
+		)
+			return;
+		event.preventDefault();
+		field.focus();
+		field.select();
+	}
 </script>
 
+<svelte:window onkeydown={renameShortcut} />
+
 <header class="flex min-h-16 flex-col justify-center gap-0.5 px-6 py-2">
 	{#if crumbs.length > 0}
 		<nav aria-label="Folder" class="min-w-0">
diff --git a/apps/app/src/lib/components/live-markdown-surface.svelte b/apps/app/src/lib/components/live-markdown-surface.svelte
index 0a8ee04..14f3659 100644
--- a/apps/app/src/lib/components/live-markdown-surface.svelte
+++ b/apps/app/src/lib/components/live-markdown-surface.svelte
@@ -251,7 +251,7 @@
 <div class="flex h-full min-h-0 flex-1 flex-col">
 	{#if showToolbar && !readOnly}
 		<div
-			class="flex min-h-11 items-center gap-1 overflow-x-auto px-5 py-1.5"
+			class="flex min-h-11 flex-wrap items-center gap-1 px-5 py-1.5"
 			role="toolbar"
 			aria-label="Formatting"
 		>
diff --git a/apps/app/src/lib/components/note-editor.svelte b/apps/app/src/lib/components/note-editor.svelte
index 241e3b1..8da1301 100644
--- a/apps/app/src/lib/components/note-editor.svelte
+++ b/apps/app/src/lib/components/note-editor.svelte
@@ -110,6 +110,7 @@
 						status: 'saved',
 						base: baseOf(result.value),
 						canonical: result.value,
+						merged: result.merged,
 					};
 				},
 				read: async () => {
@@ -152,6 +153,20 @@
 					}
 				: null,
 		);
+		if (handle && focusWhenReady) {
+			focusWhenReady = false;
+			handle.focus();
+		}
+	}
+
+	/**
+	 * Enter in the name moves on to the text. The text editor may still be
+	 * loading then; it takes the caret as soon as it is ready.
+	 */
+	let focusWhenReady = false;
+	function focusText() {
+		if (editor) editor.focus();
+		else focusWhenReady = true;
 	}
 
 	function openConflict(draft: NoteDraft, file: Note, deleted = false) {
@@ -449,7 +464,7 @@
 				activationInProgress ||
 				collaboration?.bootstrap.readOnly}
 			onrename={rename}
-			ondone={() => editor?.focus()}
+			ondone={focusText}
 		/>
 		<Separator />
 
diff --git a/apps/app/src/lib/components/project-board.svelte b/apps/app/src/lib/components/project-board.svelte
index 1ff79c6..98c6fca 100644
--- a/apps/app/src/lib/components/project-board.svelte
+++ b/apps/app/src/lib/components/project-board.svelte
@@ -1,4 +1,5 @@
 <script lang="ts">
+	import { choiceLabel } from '$lib/property-labels';
 	import { getNouraClient } from '$lib/state.svelte';
 	import { toast } from 'svelte-sonner';
 	import { tabsStore } from '$lib/tabs.svelte';
@@ -42,11 +43,7 @@
 	let dragOverColumn = $state<string | null>(null);
 	let dragOverTaskId = $state<string | null>(null);
 
-	const columnLabel = (id: string) =>
-		id
-			.split('-')
-			.map((part) => part.charAt(0).toUpperCase() + part.slice(1))
-			.join(' ');
+	const columnLabel = choiceLabel;
 
 	const isEmpty = $derived(
 		groups.every((g: KanbanGroup) => g.items.length === 0),
diff --git a/apps/app/src/lib/components/project-overview.svelte b/apps/app/src/lib/components/project-overview.svelte
index 5afdd90..eea0495 100644
--- a/apps/app/src/lib/components/project-overview.svelte
+++ b/apps/app/src/lib/components/project-overview.svelte
@@ -5,6 +5,7 @@
 	import type { CoreEvent, Project } from '@noura/workspace';
 	import { isCoreError } from '@noura/workspace';
 	import { PROJECT_STATUSES } from '@noura/shared';
+	import { choiceLabel } from '$lib/property-labels';
 	import { getNouraClient } from '$lib/state.svelte';
 	import {
 		ManagedDraftSession,
@@ -182,12 +183,12 @@
 			value={String(properties.status ?? 'planned')}
 			onValueChange={(value) => value && editStatus(value)}
 			><Select.Trigger size="sm" class="w-36" aria-label="Project status"
-				>{String(properties.status ?? 'planned')}</Select.Trigger
+				>{choiceLabel(String(properties.status ?? 'planned'))}</Select.Trigger
 			><Select.Content
 				><Select.Group
 					>{#each statuses as status (status)}<Select.Item
 							value={status}
-							label={status}>{status}</Select.Item
+							label={choiceLabel(status)}>{choiceLabel(status)}</Select.Item
 						>{/each}</Select.Group
 				></Select.Content
 			></Select.Root
diff --git a/apps/app/src/lib/components/property-choice.svelte b/apps/app/src/lib/components/property-choice.svelte
index 75bcc94..32dfe26 100644
--- a/apps/app/src/lib/components/property-choice.svelte
+++ b/apps/app/src/lib/components/property-choice.svelte
@@ -1,5 +1,6 @@
 <script lang="ts">
 	import * as Select from '$lib/components/ui/select';
+	import { choiceLabel } from '$lib/property-labels';
 	let {
 		id,
 		label,
@@ -23,13 +24,13 @@
 
 <Select.Root type="single" {value} {disabled} onValueChange={onchange}>
 	<Select.Trigger {id} {size} class={className} aria-label={label}
-		>{value}</Select.Trigger
+		>{choiceLabel(value)}</Select.Trigger
 	>
 	<Select.Content
 		><Select.Group>
 			{#each options as option (option)}<Select.Item
 					value={option}
-					label={option}>{option}</Select.Item
+					label={choiceLabel(option)}>{choiceLabel(option)}</Select.Item
 				>{/each}
 		</Select.Group></Select.Content
 	>
diff --git a/apps/app/src/lib/components/raw-markdown-editor.svelte b/apps/app/src/lib/components/raw-markdown-editor.svelte
index dbe36a6..aa6aaae 100644
--- a/apps/app/src/lib/components/raw-markdown-editor.svelte
+++ b/apps/app/src/lib/components/raw-markdown-editor.svelte
@@ -112,6 +112,9 @@
 				return {
 					status: 'saved',
 					base: baseOf(result.current),
+					// The save says merged when it folded in an edit made outside the
+					// app; otherwise it wrote the text exactly as sent.
+					merged: result.status === 'merged',
 					canonical: {
 						read: result.current,
 						managedObject: result.managedObject,
@@ -235,6 +238,20 @@
 					}
 				: null,
 		);
+		if (handle && focusWhenReady) {
+			focusWhenReady = false;
+			handle.focus();
+		}
+	}
+
+	/**
+	 * Enter in the name moves on to the text. The text editor may still be
+	 * loading then; it takes the caret as soon as it is ready.
+	 */
+	let focusWhenReady = false;
+	function focusText() {
+		if (editor) editor.focus();
+		else focusWhenReady = true;
 	}
 
 	async function rename(name: string) {
@@ -395,7 +412,7 @@
 		relativePath={path}
 		disabled={collaborationOpening || activationInProgress}
 		onrename={rename}
-		ondone={() => editor?.focus()}
+		ondone={focusText}
 	/>
 	<Separator />
 	{#if parseStatus === 'malformed'}
diff --git a/apps/app/src/lib/components/tabs-bar.svelte b/apps/app/src/lib/components/tabs-bar.svelte
index d760355..9248f66 100644
--- a/apps/app/src/lib/components/tabs-bar.svelte
+++ b/apps/app/src/lib/components/tabs-bar.svelte
@@ -3,6 +3,7 @@
 	import { page } from '$app/state';
 	import { tabHref, tabsStore } from '$lib/tabs.svelte';
 	import { activateTab, closeTab } from '$lib/tab-actions';
+	import { onMount } from 'svelte';
 	import { lastRoute } from '$lib/last-route';
 	import { workspace } from '$lib/state.svelte';
 	import { cn } from '$lib/utils.js';
@@ -41,12 +42,32 @@
 		};
 	};
 
-	afterNavigate(({ to }) => {
-		if (!to) return;
-		const redirect = lastRoute.arrived(workspace.state?.workspaceId, to.url);
+	function arrived(url: URL) {
+		const redirect = lastRoute.arrived(workspace.state?.workspaceId, url);
 		if (redirect) void goto(redirect, { replaceState: true });
+	}
+
+	// The bar mounts once the workspace is ready, after the navigation that
+	// opened the app has finished, so it handles that page on mount.
+	onMount(() => arrived(page.url));
+	afterNavigate(({ to }) => {
+		if (to) arrived(to.url);
 	});
 
+	// The bar has no visible scrollbar, which would squeeze the tabs in the
+	// title bar row. A mouse wheel scrolls it sideways; trackpads already do.
+	// The listener is not passive, so it can stop the page from scrolling.
+	const scrollTabs: Attachment<HTMLElement> = (bar) => {
+		const scroll = (event: WheelEvent) => {
+			if (bar.scrollWidth <= bar.clientWidth) return;
+			if (Math.abs(event.deltaY) <= Math.abs(event.deltaX)) return;
+			event.preventDefault();
+			bar.scrollLeft += event.deltaY;
+		};
+		bar.addEventListener('wheel', scroll, { passive: false });
+		return () => bar.removeEventListener('wheel', scroll);
+	};
+
 	function focusTab(index: number) {
 		const tab = tabsStore.tabs[index];
 		if (tab) document.getElementById(`tab-${tab.id}`)?.focus();
@@ -112,9 +133,10 @@
 	<div
 		role="tablist"
 		aria-label="Open files"
-		class="fixed top-0 right-0 z-20 flex h-(--app-titlebar-height) min-w-0 items-center gap-0.5 overflow-x-auto border-b border-sidebar-border bg-sidebar px-2"
+		class="fixed top-0 right-0 z-20 flex h-(--app-titlebar-height) min-w-0 items-center gap-0.5 overflow-x-auto overflow-y-hidden border-b border-sidebar-border bg-sidebar px-2 [scrollbar-width:none] [&::-webkit-scrollbar]:hidden"
 		style="left: {left}px"
 		data-tauri-drag-region
+		{@attach scrollTabs}
 	>
 		{#each tabsStore.tabs as tab, index (tab.id)}
 			{@const isActive = tabsStore.activeId === tab.id}
@@ -130,6 +152,11 @@
 					// Middle-click closes instead of starting auto-scroll.
 					if (event.button === 1) event.preventDefault();
 				}}
+				onmouseup={(event) => {
+					// On Linux a middle-click release pastes the last selected text
+					// into the focused note; closing a tab must not do that.
+					if (event.button === 1) event.preventDefault();
+				}}
 				onauxclick={(event) => {
 					if (event.button !== 1) return;
 					event.preventDefault();
diff --git a/apps/app/src/lib/components/workspace-shell.svelte b/apps/app/src/lib/components/workspace-shell.svelte
index 5ed733c..ea1a38a 100644
--- a/apps/app/src/lib/components/workspace-shell.svelte
+++ b/apps/app/src/lib/components/workspace-shell.svelte
@@ -82,7 +82,10 @@
 
 	// Until a lazy component is mounted it cannot hear its own shortcut.
 	// Once it is, it owns the key and this handler stays out of the way.
+	// A key the focused control already handled (Cmd-K adds a link in the
+	// editor) is not a shortcut.
 	function handleKeydown(event: KeyboardEvent) {
+		if (event.defaultPrevented) return;
 		if (!(event.metaKey || event.ctrlKey) || event.repeat) return;
 		const key = event.key.toLowerCase();
 		if (key === 'k' && !Palette) {
@@ -165,8 +168,12 @@
 
 	// Turned-off modules genuinely simplify the workspace: routes backed by a
 	// disabled plugin fall back to Home instead of rendering a dead surface.
+	// Only the open workspace's own plugin list decides: a sync that settled
+	// while it was still opening lists no plugins at all.
 	$effect(() => {
 		if (!plugins.synced) return;
+		if (!readyWorkspaceId || plugins.syncedWorkspaceId !== readyWorkspaceId)
+			return;
 		const pluginId = routePlugin(page.url.pathname);
 		if (pluginId && !plugins.isEnabled(pluginId))
 			void goto('/inbox', { replaceState: true });
diff --git a/apps/app/src/lib/dashboard.svelte.ts b/apps/app/src/lib/dashboard.svelte.ts
index 9861727..7e7b051 100644
--- a/apps/app/src/lib/dashboard.svelte.ts
+++ b/apps/app/src/lib/dashboard.svelte.ts
@@ -118,7 +118,11 @@ class DashboardStore {
 	/** Create a task through the tasks plugin command, then refresh Today. */
 	async addTask(title: string): Promise<void> {
 		if (title.trim().length === 0) return;
-		await getNouraClient().commands.execute('tasks.create', { title });
+		// Home adds tasks for today; without a due date one would not show here.
+		await getNouraClient().commands.execute('tasks.create', {
+			title,
+			properties: { due: localDate(new Date()) },
+		});
 		await this.refresh({ tasks: true, calendar: false, notes: false });
 	}
 
diff --git a/apps/app/src/lib/editor/document-session.test.ts b/apps/app/src/lib/editor/document-session.test.ts
index 7b337f2..5301d82 100644
--- a/apps/app/src/lib/editor/document-session.test.ts
+++ b/apps/app/src/lib/editor/document-session.test.ts
@@ -36,13 +36,18 @@ class FakeFile {
 		this.body = body;
 		this.revision += 1;
 	}
+	/** How the file stores text; the note format drops trailing blank lines. */
+	normalize = (text: string) => text;
 	save(base: TextBase, local: string): SessionSaveResult<string> {
-		const merged =
-			base.revision === String(this.revision)
-				? local
-				: rebaseText(base.body, local, this.body);
-		this.writeExternally(merged);
-		return { status: 'saved', base: this.base, canonical: this.body };
+		const external = base.revision !== String(this.revision);
+		const merged = external ? rebaseText(base.body, local, this.body) : local;
+		this.writeExternally(this.normalize(merged));
+		return {
+			status: 'saved',
+			base: this.base,
+			canonical: this.body,
+			merged: external,
+		};
 	}
 }
 
@@ -58,6 +63,7 @@ function setup(initial: string) {
 	let gate: Promise<void> | null = null;
 	let readGate: Promise<void> | null = null;
 	const saved: string[] = [];
+	const merges = { count: 0 };
 	const session = new DocumentSession<string>({
 		base: file.base,
 		// Timers never fire on their own; tests flush explicitly.
@@ -76,6 +82,9 @@ function setup(initial: string) {
 		onConflict: () => {
 			throw new Error('unexpected conflict');
 		},
+		onMerged: () => {
+			merges.count += 1;
+		},
 	});
 	session.attach(editor);
 	return {
@@ -83,6 +92,7 @@ function setup(initial: string) {
 		editor,
 		session,
 		saved,
+		merges,
 		holdSaves() {
 			const hold = deferred();
 			gate = hold.promise;
@@ -135,6 +145,24 @@ describe('DocumentSession', () => {
 		expect(file.body).toBe('outside\nline\none two');
 	});
 
+	test('a save that normalizes the text leaves what was typed on screen', async () => {
+		const { editor, session, file, merges } = setup('Hello');
+		// Like the note format, which ends the file with one newline.
+		file.normalize = (text) => text.replace(/\s+$/, '');
+		editor.type(' ', session);
+		await session.flush();
+		expect(file.body).toBe('Hello');
+		expect(editor.value).toBe('Hello ');
+		editor.type('\n', session);
+		await session.flush();
+		expect(editor.value).toBe('Hello \n');
+		editor.type('world', session);
+		await session.flush();
+		expect(editor.value).toBe('Hello \nworld');
+		expect(file.body).toBe('Hello \nworld');
+		expect(merges.count).toBe(0);
+	});
+
 	test('a reload keeps text typed while the file was being read', async () => {
 		const { editor, session, file, holdReads } = setup('a\n');
 		file.writeExternally('a\nfrom outside\n');
@@ -182,4 +210,19 @@ describe('DocumentSession', () => {
 		const seen = await session.exclusive(async () => file.body);
 		expect(seen).toBe('ab');
 	});
+
+	test('a flush during an exclusive operation waits for it, then saves', async () => {
+		const { editor, session, file } = setup('a');
+		const rename = deferred();
+		const renaming = session.exclusive(() => rename.promise);
+		// Let the operation start, then type while it holds autosave.
+		await Promise.resolve();
+		await Promise.resolve();
+		editor.type('b', session);
+		const flushing = session.flush();
+		rename.resolve();
+		await renaming;
+		await expect(flushing).resolves.toBe(true);
+		expect(file.body).toBe('ab');
+	});
 });
diff --git a/apps/app/src/lib/editor/document-session.ts b/apps/app/src/lib/editor/document-session.ts
index 5167c36..8835130 100644
--- a/apps/app/src/lib/editor/document-session.ts
+++ b/apps/app/src/lib/editor/document-session.ts
@@ -25,7 +25,17 @@ export interface TextBase {
 }
 
 export type SessionSaveResult<Canonical> =
-	| { status: 'saved'; base: TextBase; canonical: Canonical }
+	| {
+			status: 'saved';
+			base: TextBase;
+			canonical: Canonical;
+			/**
+			 * The save folded in an edit made outside the editor. Without one, the
+			 * file holds this editor's text, possibly normalized, and the text on
+			 * screen stays as typed.
+			 */
+			merged?: boolean;
+	  }
 	| { status: 'conflict'; current: Canonical };
 
 export interface DocumentSessionOptions<Canonical> {
@@ -67,6 +77,7 @@ export class DocumentSession<Canonical> {
 	#base: TextBase;
 	#editor: EditorPort | null = null;
 	#discarded = false;
+	#exclusive: Promise<unknown> | null = null;
 	readonly #options: DocumentSessionOptions<Canonical>;
 
 	constructor(options: DocumentSessionOptions<Canonical>) {
@@ -117,8 +128,14 @@ export class DocumentSession<Canonical> {
 		);
 	}
 
-	flush(): Promise<boolean> {
-		if (this.#discarded) return Promise.resolve(true);
+	/**
+	 * Save every edit now. An exclusive operation (a rename) holds autosave
+	 * while it runs; the flush waits for it instead of failing, so closing a
+	 * note right after renaming it still saves what was typed.
+	 */
+	async flush(): Promise<boolean> {
+		while (this.#exclusive) await this.#exclusive.catch(() => {});
+		if (this.#discarded) return true;
 		return this.autosave.flush();
 	}
 
@@ -131,10 +148,18 @@ export class DocumentSession<Canonical> {
 			throw new Error('Save your changes before renaming.');
 		}
 		this.autosave.pause();
+		const running = (async () => {
+			try {
+				return await operation();
+			} finally {
+				this.autosave.resume();
+			}
+		})();
+		this.#exclusive = running;
 		try {
-			return await operation();
+			return await running;
 		} finally {
-			this.autosave.resume();
+			if (this.#exclusive === running) this.#exclusive = null;
 		}
 	}
 
@@ -215,7 +240,10 @@ export class DocumentSession<Canonical> {
 			return 'paused';
 		}
 		this.#base = result.base;
-		if (result.base.body !== body) {
+		// Only a real merge changes the text on screen. Saving can normalize
+		// what was typed, such as a trailing space or a final blank line;
+		// replacing the editor's text with that would undo the keystroke.
+		if (result.merged && result.base.body !== body) {
 			this.#editor?.rebase(body, result.base.body);
 			options.onMerged?.();
 		}
diff --git a/apps/app/src/lib/editor/managed-draft-session.ts b/apps/app/src/lib/editor/managed-draft-session.ts
index 0f65d02..c7da13a 100644
--- a/apps/app/src/lib/editor/managed-draft-session.ts
+++ b/apps/app/src/lib/editor/managed-draft-session.ts
@@ -252,10 +252,12 @@ export class ManagedDraftSession<Canonical extends ManagedCanonical> {
 					}
 				: draftOf(result.current);
 		this.#base = result.current;
-		if (!sameDraft(local, saved)) {
+		// Only a merged save changes what is on screen. A plain save can
+		// normalize the draft (a trailing space, a final blank line), and
+		// replacing the fields with that would undo what was just typed.
+		if (result.status === 'merged' && !sameDraft(local, saved)) {
 			this.#port?.rebase(local, saved);
-			if (result.status === 'merged' && result.body !== local.body)
-				this.#options.onMerged?.();
+			if (result.body !== local.body) this.#options.onMerged?.();
 		}
 		this.#options.onCanonical?.(result.current);
 	}
diff --git a/apps/app/src/lib/editor/note-save.ts b/apps/app/src/lib/editor/note-save.ts
index 16ca0bf..ba1d233 100644
--- a/apps/app/src/lib/editor/note-save.ts
+++ b/apps/app/src/lib/editor/note-save.ts
@@ -4,7 +4,7 @@ import type { Note } from '@noura/workspace';
 import { reconcileNoteTitle } from './title-reconciliation';
 
 export type NoteSaveResult =
-	| { status: 'saved'; value: Note }
+	| { status: 'saved'; value: Note; merged: boolean }
 	| { status: 'conflict'; draft: NoteDraft; current: Note };
 
 export interface NoteDraft {
@@ -26,6 +26,7 @@ export async function saveNoteWithReconciliation(
 	let currentBaseBody = base.body;
 	let currentBaseTitle = base.title;
 	let currentBaseRevision = base.revision;
+	let merged = false;
 	for (let attempt = 0; attempt < 3; attempt += 1) {
 		const reconciliation = await getNouraClient().notes.reconcileDraft({
 			id: note.id,
@@ -40,6 +41,13 @@ export async function saveNoteWithReconciliation(
 				current: reconciliation.current as Note,
 			};
 		}
+		// A changed revision can be a title or property edit; only an outside
+		// change to the body means the text on screen must follow the file.
+		if (
+			reconciliation.status === 'merged' &&
+			reconciliation.body !== currentDraft.body
+		)
+			merged = true;
 		const canonical = reconciliation.current as Note;
 		const title = reconcileNoteTitle(
 			currentBaseTitle,
@@ -59,7 +67,7 @@ export async function saveNoteWithReconciliation(
 				title: currentDraft.title,
 				body: currentDraft.body,
 			});
-			return { status: 'saved', value: result.value as Note };
+			return { status: 'saved', value: result.value as Note, merged };
 		} catch (error) {
 			if (
 				!isCoreError(error) ||
diff --git a/apps/app/src/lib/file-actions.ts b/apps/app/src/lib/file-actions.ts
index 8f1937a..f575530 100644
--- a/apps/app/src/lib/file-actions.ts
+++ b/apps/app/src/lib/file-actions.ts
@@ -5,7 +5,7 @@ import { isCoreError } from '@noura/workspace';
 import { flushPendingDrafts } from './editor/pending-drafts.svelte';
 import { getNouraClient, workspace } from './state.svelte';
 import { hostCapabilities } from './host-capabilities.svelte';
-import { tabsStore } from './tabs.svelte';
+import { tabHref, tabsStore } from './tabs.svelte';
 import {
 	baseName,
 	canMoveInto,
@@ -294,7 +294,12 @@ export async function trashTreeNode(node: WorkspaceTreeNode) {
 			? `Moved ${quoted(node)} to .noura/trash in this workspace.`
 			: `Moved ${quoted(node)} to the trash.`,
 	);
-	if (showing) await goto(url.pathname, { replaceState: true });
+	// Show the tab that took the closed tab's place, as closing a tab does,
+	// so the page and the highlighted tab agree.
+	if (showing) {
+		const next = tabsStore.active;
+		await goto(next ? tabHref(next) : url.pathname, { replaceState: true });
+	}
 }
 
 export async function revealTreeNode(node: WorkspaceTreeNode) {
diff --git a/apps/app/src/lib/plugins.svelte.ts b/apps/app/src/lib/plugins.svelte.ts
index 8ea1a74..5e9d6f9 100644
--- a/apps/app/src/lib/plugins.svelte.ts
+++ b/apps/app/src/lib/plugins.svelte.ts
@@ -65,6 +65,12 @@ class PluginStore {
 	lastError = $state<string | null>(null);
 	/** True once the first sync for a workspace context has settled. */
 	synced = $state(false);
+	/**
+	 * The workspace whose manifest the plugins last synced with, or null
+	 * when none was open. A sync can settle while a workspace is still
+	 * opening; its empty plugin list does not describe that workspace.
+	 */
+	syncedWorkspaceId = $state<string | null>(null);
 
 	#initialized = false;
 	#syncChain: Promise<void> = Promise.resolve();
@@ -142,6 +148,7 @@ class PluginStore {
 			this.synced = true;
 			return;
 		}
+		const workspaceId = workspace.state?.workspaceId ?? null;
 		try {
 			const result = await getPluginRuntime().syncWithManifest();
 			const runtime = getPluginRuntime();
@@ -149,6 +156,7 @@ class PluginStore {
 			this.enabledIds = result.enabledPluginIds;
 			this.#loadPluginOrder(workspace.state?.workspaceId ?? null);
 			this.lastError = null;
+			this.syncedWorkspaceId = workspaceId;
 		} catch (error) {
 			if (isCoreError(error) && error.code === 'workspace_not_open') {
 				// Onboarding or a closed workspace: no manifest is scoped,
@@ -160,6 +168,7 @@ class PluginStore {
 				this.enabledIds = [];
 				this.#loadPluginOrder(null);
 				this.lastError = null;
+				this.syncedWorkspaceId = null;
 				return;
 			}
 			this.lastError = errorMessage(error);
diff --git a/apps/app/src/lib/property-labels.test.ts b/apps/app/src/lib/property-labels.test.ts
new file mode 100644
index 0000000..982cb86
--- /dev/null
+++ b/apps/app/src/lib/property-labels.test.ts
@@ -0,0 +1,30 @@
+import { expect, test } from 'bun:test';
+import {
+	PROJECT_STATUSES,
+	TASK_PRIORITIES,
+	TASK_STATUSES,
+} from '@noura/shared';
+import { choiceLabel } from './property-labels';
+
+test('statuses and priorities read as words', () => {
+	expect(TASK_STATUSES.map(choiceLabel)).toEqual([
+		'To do',
+		'In progress',
+		'Done',
+		'Cancelled',
+	]);
+	expect(TASK_PRIORITIES.map(choiceLabel)).toEqual([
+		'Low',
+		'Medium',
+		'High',
+		'Urgent',
+	]);
+	expect(PROJECT_STATUSES.map(choiceLabel)).toEqual([
+		'Planned',
+		'Active',
+		'On hold',
+		'Completed',
+		'Cancelled',
+	]);
+	expect(choiceLabel('some-new-value')).toBe('Some new value');
+});
diff --git a/apps/app/src/lib/property-labels.ts b/apps/app/src/lib/property-labels.ts
new file mode 100644
index 0000000..1068589
--- /dev/null
+++ b/apps/app/src/lib/property-labels.ts
@@ -0,0 +1,16 @@
+const LABELS: Record<string, string> = {
+	todo: 'To do',
+	'in-progress': 'In progress',
+	'on-hold': 'On hold',
+};
+
+/**
+ * A property value as words: "in-progress" reads "In progress", "todo"
+ * reads "To do". Values are stored as IDs; people see labels.
+ */
+export function choiceLabel(value: string): string {
+	const known = LABELS[value];
+	if (known) return known;
+	const words = value.replaceAll('-', ' ');
+	return words.charAt(0).toUpperCase() + words.slice(1);
+}
diff --git a/apps/app/src/lib/tab-actions.ts b/apps/app/src/lib/tab-actions.ts
index d323095..011cca4 100644
--- a/apps/app/src/lib/tab-actions.ts
+++ b/apps/app/src/lib/tab-actions.ts
@@ -1,6 +1,7 @@
 import { goto } from '$app/navigation';
 import { page } from '$app/state';
 import { tabHref, tabsStore } from './tabs.svelte';
+import { saveBeforeLeaving } from './editor/unsaved-changes';
 
 /** Show a tab's document. */
 export async function activateTab(id: string): Promise<void> {
@@ -15,6 +16,17 @@ export async function activateTab(id: string): Promise<void> {
  * page with nothing open when it was the last tab.
  */
 export async function closeTab(id: string): Promise<void> {
+	// The tab on screen takes its editor with it: save what was typed first,
+	// or let the user decide when it can't be saved.
+	if (
+		tabsStore.activeId === id &&
+		!(await saveBeforeLeaving(() => removeTab(id)))
+	)
+		return;
+	await removeTab(id);
+}
+
+async function removeTab(id: string): Promise<void> {
 	const wasActive = tabsStore.activeId === id;
 	tabsStore.close(id);
 	if (!wasActive) return;
diff --git a/apps/app/src/routes/(workspace)/files/+page.svelte b/apps/app/src/routes/(workspace)/files/+page.svelte
index 9c5dc4d..65140f8 100644
--- a/apps/app/src/routes/(workspace)/files/+page.svelte
+++ b/apps/app/src/routes/(workspace)/files/+page.svelte
@@ -11,11 +11,12 @@
 		type UnmanagedFile,
 		type WorkspaceObject,
 	} from '@noura/workspace';
-	import { tabsStore } from '$lib/tabs.svelte';
+	import { tabHref, tabsStore } from '$lib/tabs.svelte';
 	import { saveBeforeLeaving } from '$lib/editor/unsaved-changes';
 	import { splitFileName } from '$lib/editor/rename';
 	import NoteEditor from '$lib/components/note-editor.svelte';
 	import RawMarkdownEditor from '$lib/components/raw-markdown-editor.svelte';
+	import { onMount } from 'svelte';
 	import { afterNavigate, goto } from '$app/navigation';
 	import { page } from '$app/state';
 	import { toast } from 'svelte-sonner';
@@ -128,9 +129,27 @@
 		if (await leaveCurrent(show)) show();
 	}
 
+	/**
+	 * Plain /files keeps whatever is already open, like any editor surface.
+	 * With nothing open it shows the active tab's document, so the page and
+	 * the highlighted tab agree.
+	 */
+	function showActiveTab() {
+		if (shownNote || shownRaw) return;
+		const active = tabsStore.active;
+		if (!active) return;
+		const href = tabHref(active);
+		if (new URL(href, page.url).pathname === page.url.pathname)
+			void goto(href, { replaceState: true });
+	}
+
 	// Selection is URL-driven: /files?selected=<id> or /files?raw=<path>.
-	// Plain /files keeps whatever is already open, like any editor surface.
-	afterNavigate(() => {
+	// The page mounts once the workspace is ready, after the navigation that
+	// opened the app, so it applies the address on mount too.
+	onMount(() => applyAddress());
+	afterNavigate(() => applyAddress());
+
+	function applyAddress() {
 		const params = page.url.searchParams;
 		const selectedId = params.get('selected');
 		const rawPath = params.get('raw');
@@ -138,7 +157,10 @@
 		if (key === appliedKey) return;
 		const generation = ++selectionGeneration;
 		appliedKey = key;
-		if (key === '|') return;
+		if (key === '|') {
+			showActiveTab();
+			return;
+		}
 		if (shownNote?.id === selectedId) return;
 		if (shownRaw?.relativePath === rawPath) return;
 		void (async () => {
@@ -178,7 +200,7 @@
 					);
 			}
 		})();
-	});
+	}
 
 	function handleSaved(updated: Note) {
 		selected = updated;
diff --git a/apps/app/src/routes/(workspace)/projects/+page.svelte b/apps/app/src/routes/(workspace)/projects/+page.svelte
index 59d46db..425703c 100644
--- a/apps/app/src/routes/(workspace)/projects/+page.svelte
+++ b/apps/app/src/routes/(workspace)/projects/+page.svelte
@@ -1,4 +1,5 @@
 <script lang="ts">
+	import { choiceLabel } from '$lib/property-labels';
 	import { getRouteSidebar } from '$lib/route-sidebar.svelte';
 	const routeSidebar = getRouteSidebar();
 	import * as Sidebar from '$lib/components/ui/sidebar/index.js';
@@ -273,8 +274,7 @@
 	/** "on-hold" reads as "On hold". */
 	function statusLabel(status: unknown, fallback: string): string {
 		const value = typeof status === 'string' && status ? status : fallback;
-		const words = value.replaceAll('-', ' ');
-		return words.charAt(0).toUpperCase() + words.slice(1);
+		return value ? choiceLabel(value) : '';
 	}
 
 	const statusVariants: Record<
diff --git a/apps/app/tests/e2e/editor-editing.e2e.ts b/apps/app/tests/e2e/editor-editing.e2e.ts
new file mode 100644
index 0000000..8a9cfed
--- /dev/null
+++ b/apps/app/tests/e2e/editor-editing.e2e.ts
@@ -0,0 +1,181 @@
+import { expect, noteFileBody, test, type App } from './fixtures';
+
+async function expectStoredBody(app: App, path: string, typed: string) {
+	await expect
+		.poll(() => app.storedBody(path), { timeout: 10_000 })
+		.toBe(noteFileBody(typed));
+}
+
+test.describe('editing a note', () => {
+	test('keeps typing while a save waits for the disk', async ({
+		app,
+		page,
+	}) => {
+		await app.newNote('Slow');
+		await page.keyboard.type('before ');
+		await expectStoredBody(app, 'Slow.md', 'before ');
+		const release = await app.holdStorage();
+		await page.keyboard.type('during');
+		// The debounced save starts and waits for the disk.
+		await expect.poll(() => app.storageWaiting()).toBe(true);
+		await page.keyboard.type(' more ');
+		await page.keyboard.press('Enter');
+		await page.keyboard.type('next');
+		expect(await app.doc()).toBe('before during more \nnext');
+		await release();
+		await expectStoredBody(app, 'Slow.md', 'before during more \nnext');
+		expect(await app.doc()).toBe('before during more \nnext');
+		expect(await app.caret()).toBe('before during more \nnext'.length);
+		expect(await app.messages()).toEqual([]);
+	});
+
+	test('Tab and Shift-Tab nest and lift list items', async ({ app, page }) => {
+		await app.newNote('List');
+		await page.keyboard.type('- one');
+		await page.keyboard.press('Enter');
+		await page.keyboard.type('two');
+		await page.keyboard.press('Tab');
+		expect(await app.doc()).toBe('- one\n  - two');
+		await page.keyboard.press('Enter');
+		await page.keyboard.type('three');
+		await page.keyboard.press('Shift+Tab');
+		expect(await app.doc()).toBe('- one\n  - two\n- three');
+		await expectStoredBody(app, 'List.md', '- one\n  - two\n- three');
+		// Tab outside a list keeps focus in the editor.
+		await page.keyboard.press('Enter');
+		await page.keyboard.press('Enter');
+		await expect(app.editor()).toBeFocused();
+		expect(await app.messages()).toEqual([]);
+	});
+
+	test('double spaces and a Markdown line break survive', async ({
+		app,
+		page,
+	}) => {
+		await app.newNote('Break');
+		await page.keyboard.type('line  ');
+		await page.keyboard.press('Enter');
+		await page.keyboard.type('next  word');
+		await expectStoredBody(app, 'Break.md', 'line  \nnext  word');
+		expect(await app.doc()).toBe('line  \nnext  word');
+	});
+
+	test('text composed with an input method is kept', async ({ app, page }) => {
+		await app.newNote('Compose');
+		await page.keyboard.type('start ');
+		const cdp = await page.context().newCDPSession(page);
+		await cdp.send('Input.imeSetComposition', {
+			text: 'に',
+			selectionStart: 1,
+			selectionEnd: 1,
+		});
+		await cdp.send('Input.imeSetComposition', {
+			text: 'にほ',
+			selectionStart: 2,
+			selectionEnd: 2,
+		});
+		// Wait past the debounce while the composition is open.
+		await page.waitForTimeout(700);
+		await cdp.send('Input.insertText', { text: '日本' });
+		await page.keyboard.type(' end');
+		await expectStoredBody(app, 'Compose.md', 'start 日本 end');
+		expect(await app.doc()).toBe('start 日本 end');
+		expect(await app.messages()).toEqual([]);
+	});
+
+	test('formatting shortcuts wrap the selection', async ({ app, page }) => {
+		await app.newNote('Format');
+		const selectWord = async (word: string) => {
+			await page.keyboard.type(word);
+			for (let index = 0; index < word.length; index += 1)
+				await page.keyboard.press('Shift+ArrowLeft');
+		};
+		await selectWord('bold');
+		await page.keyboard.press('ControlOrMeta+b');
+		await page.keyboard.press('End');
+		await page.keyboard.type(' ');
+		await selectWord('it');
+		await page.keyboard.press('ControlOrMeta+i');
+		await page.keyboard.press('End');
+		await page.keyboard.type(' ');
+		await selectWord('under');
+		await page.keyboard.press('ControlOrMeta+u');
+		await page.keyboard.press('End');
+		await page.keyboard.type(' ');
+		await selectWord('gone');
+		await page.keyboard.press('ControlOrMeta+Shift+KeyX');
+		await page.keyboard.press('End');
+		await page.keyboard.type(' ');
+		await selectWord('site');
+		// Cmd-K adds a link here; it must not also open the command palette.
+		await page.keyboard.press('ControlOrMeta+k');
+		await page.keyboard.type('https://example.com');
+		await expect(app.editor()).toBeFocused();
+		await expect(
+			page.getByRole('dialog', { name: 'Search and commands' }),
+		).toBeHidden();
+		const expected =
+			'**bold** *it* <u>under</u> ~~gone~~ [site](https://example.com)';
+		expect(await app.doc()).toBe(expected);
+		await expectStoredBody(app, 'Format.md', expected);
+		// The same shortcut removes the formatting again.
+		await app.editor().getByText('bold', { exact: true }).dblclick();
+		await page.keyboard.press('ControlOrMeta+b');
+		expect(await app.doc()).toBe(expected.replace('**bold**', 'bold'));
+	});
+
+	test('Cmd-K adds a link after the command palette has loaded', async ({
+		app,
+		page,
+	}) => {
+		const palette = page.getByRole('dialog', { name: 'Search and commands' });
+		await page.getByRole('button', { name: 'Search' }).click();
+		await expect(palette).toBeVisible();
+		await page.keyboard.press('Escape');
+		await expect(palette).toBeHidden();
+		await app.newNote('Link');
+		await page.keyboard.press('ControlOrMeta+k');
+		await page.keyboard.type('label');
+		expect(await app.doc()).toBe('[label]()');
+		await expect(palette).toBeHidden();
+		// Outside the editor, Cmd-K still opens the palette.
+		await page.getByRole('button', { name: 'New folder' }).focus();
+		await page.keyboard.press('ControlOrMeta+k');
+		await expect(palette).toBeVisible();
+	});
+
+	test('toolbar buttons and checklists', async ({ app, page }) => {
+		await app.newNote('Toolbar');
+		await page.keyboard.type('buy milk');
+		await page.getByRole('button', { name: 'Checklist' }).click();
+		expect(await app.doc()).toBe('- [ ] buy milk');
+		await app.caretToEnd();
+		await page.keyboard.press('Enter');
+		await page.keyboard.type('eggs');
+		expect(await app.doc()).toBe('- [ ] buy milk\n- [ ] eggs');
+		await page.keyboard.press('ControlOrMeta+Enter');
+		expect(await app.doc()).toBe('- [ ] buy milk\n- [x] eggs');
+		// Clicking the rendered checkbox checks the first item.
+		await app.editor().locator('.cm-md-checkbox').first().click();
+		expect(await app.doc()).toBe('- [x] buy milk\n- [x] eggs');
+		await expectStoredBody(app, 'Toolbar.md', '- [x] buy milk\n- [x] eggs');
+		await page.getByRole('button', { name: 'Undo', exact: true }).click();
+		expect(await app.doc()).toBe('- [ ] buy milk\n- [x] eggs');
+		await expectStoredBody(app, 'Toolbar.md', '- [ ] buy milk\n- [x] eggs');
+		expect(await app.messages()).toEqual([]);
+	});
+
+	test('find and replace', async ({ app, page }) => {
+		await app.newNote('Find');
+		await page.keyboard.type('cat and cat and dog');
+		await page.keyboard.press('ControlOrMeta+f');
+		const find = page.getByRole('textbox', { name: /find/i }).first();
+		await expect(find).toBeFocused();
+		await page.keyboard.type('cat');
+		const replace = page.getByRole('textbox', { name: /replace/i }).first();
+		await replace.fill('bird');
+		await page.getByRole('button', { name: /replace all/i }).click();
+		expect(await app.doc()).toBe('bird and bird and dog');
+		await expectStoredBody(app, 'Find.md', 'bird and bird and dog');
+	});
+});
diff --git a/apps/app/tests/e2e/editor-lifecycle.e2e.ts b/apps/app/tests/e2e/editor-lifecycle.e2e.ts
new file mode 100644
index 0000000..db310e7
--- /dev/null
+++ b/apps/app/tests/e2e/editor-lifecycle.e2e.ts
@@ -0,0 +1,140 @@
+import { expect, noteFileBody, test, type App } from './fixtures';
+
+async function expectStoredBody(app: App, path: string, typed: string) {
+	await expect
+		.poll(() => app.storedBody(path), { timeout: 10_000 })
+		.toBe(noteFileBody(typed));
+}
+
+test.describe('leaving a note right after typing', () => {
+	test('switching to another tab saves what was typed', async ({
+		app,
+		page,
+	}) => {
+		await app.newNote('Other');
+		await app.newNote('Leaving');
+		await page.keyboard.type('typed then left');
+		await page.getByRole('tab', { name: 'Other', exact: true }).click();
+		await expect(app.fileName).toHaveValue('Other');
+		await expectStoredBody(app, 'Leaving.md', 'typed then left');
+		await page.getByRole('tab', { name: 'Leaving', exact: true }).click();
+		await expect(app.fileName).toHaveValue('Leaving');
+		await expect
+			.poll(() => app.doc(), { timeout: 5000 })
+			.toBe('typed then left');
+	});
+
+	test('going Home while a save waits for the disk still saves', async ({
+		app,
+		page,
+	}) => {
+		await app.newNote('Slow leave');
+		await page.keyboard.type('first ');
+		await expectStoredBody(app, 'Slow leave.md', 'first ');
+		const release = await app.holdStorage();
+		await page.keyboard.type('second');
+		await expect.poll(() => app.storageWaiting()).toBe(true);
+		await page
+			.getByRole('navigation', { name: 'Sections' })
+			.getByRole('link', { name: 'Home' })
+			.click();
+		await release();
+		await expect(page.getByRole('heading', { level: 1 })).toContainText(/Good/);
+		await expectStoredBody(app, 'Slow leave.md', 'first second');
+	});
+
+	test('closing the tab saves what was typed', async ({ app, page }) => {
+		await app.newNote('Closing');
+		await page.keyboard.type('before closing');
+		await page.getByRole('button', { name: 'Close Closing' }).click();
+		await expect(page.getByText('No file open')).toBeVisible();
+		await expectStoredBody(app, 'Closing.md', 'before closing');
+		// Cmd-W and a middle-click close tabs the same way.
+		await app.newNote('Shortcut');
+		await page.keyboard.type('closed with the keyboard');
+		await page.keyboard.press('ControlOrMeta+w');
+		await expect(page.getByRole('tab', { name: 'Shortcut' })).toBeHidden();
+		await expectStoredBody(app, 'Shortcut.md', 'closed with the keyboard');
+		await app.newNote('Middle');
+		await page.keyboard.type('closed with the wheel');
+		await page
+			.getByRole('tab', { name: 'Middle', exact: true })
+			.click({ button: 'middle' });
+		await expect(page.getByRole('tab', { name: 'Middle' })).toBeHidden();
+		await expectStoredBody(app, 'Middle.md', 'closed with the wheel');
+	});
+
+	test('renaming from the tree while typing keeps the typing', async ({
+		app,
+		page,
+	}) => {
+		await app.newNote('Before');
+		await page.keyboard.type('some text');
+		await app.treeItem('Before').click({ button: 'right' });
+		await page.getByRole('menuitem', { name: 'Rename…' }).click();
+		await page.keyboard.type('After');
+		await page.keyboard.press('Enter');
+		await expect(app.treeItem('After')).toBeVisible();
+		await app.editor().focus();
+		await page.keyboard.press('ControlOrMeta+End');
+		await page.keyboard.type(' and more');
+		await expectStoredBody(app, 'After.md', 'some text and more');
+		expect(await app.storedPaths()).toEqual(['After.md']);
+		expect(await app.doc()).toBe('some text and more');
+	});
+
+	test('undo after an outside edit merged keeps the outside edit', async ({
+		app,
+		page,
+	}) => {
+		await app.newNote('Undo merge');
+		await page.keyboard.type('mine');
+		await expectStoredBody(app, 'Undo merge.md', 'mine');
+		const file = (await app.stored('Undo merge.md'))!;
+		await app.writeOutside('Undo merge.md', `${file}\ntheirs\n`);
+		await expect.poll(() => app.doc()).toBe('mine\n\ntheirs');
+		await app.caretToEnd();
+		await page.keyboard.type('!');
+		await expectStoredBody(app, 'Undo merge.md', 'mine\n\ntheirs!');
+		await page.keyboard.press('ControlOrMeta+z');
+		expect(await app.doc()).toBe('mine\n\ntheirs');
+		await expectStoredBody(app, 'Undo merge.md', 'mine\n\ntheirs');
+	});
+});
+
+test.describe('the same note in two browser tabs', () => {
+	test('typing in both keeps both', async ({ app, page, context }) => {
+		await app.newNote('Shared');
+		await page.keyboard.type('from one');
+		await expectStoredBody(app, 'Shared.md', 'from one');
+		const second = await context.newPage();
+		await second.goto(page.url());
+		const other = second.getByRole('textbox', {
+			name: 'Note text',
+			exact: true,
+		});
+		await expect(other).toBeVisible();
+		await other.focus();
+		await second.keyboard.press('ControlOrMeta+End');
+		await second.keyboard.press('Enter');
+		await second.keyboard.type('from two');
+		await expectStoredBody(app, 'Shared.md', 'from one\nfrom two');
+		await expect.poll(() => app.doc()).toBe('from one\nfrom two');
+		await app.editor().focus();
+		await page.keyboard.press('ControlOrMeta+Home');
+		await page.keyboard.type('> ');
+		await expectStoredBody(app, 'Shared.md', '> from one\nfrom two');
+		await expect
+			.poll(() =>
+				other.evaluate((element) => {
+					const tile = (
+						element as unknown as {
+							cmTile?: { root?: { view?: { state: { doc: object } } } };
+						}
+					).cmTile;
+					return String(tile?.root?.view?.state.doc);
+				}),
+			)
+			.toBe('> from one\nfrom two');
+	});
+});
diff --git a/apps/app/tests/e2e/editor-typing.e2e.ts b/apps/app/tests/e2e/editor-typing.e2e.ts
new file mode 100644
index 0000000..d287658
--- /dev/null
+++ b/apps/app/tests/e2e/editor-typing.e2e.ts
@@ -0,0 +1,178 @@
+import {
+	expect,
+	MERGED_MESSAGE,
+	noteFileBody,
+	test,
+	type App,
+} from './fixtures';
+
+/** Wait until the note stored at `path` holds the text typed so far. */
+async function expectStoredBody(app: App, path: string, typed: string) {
+	await expect
+		.poll(() => app.storedBody(path), { timeout: 10_000 })
+		.toBe(noteFileBody(typed));
+}
+
+test.describe('typing in a note', () => {
+	test('keeps spaces at the end of a line and of the note across saves', async ({
+		app,
+		page,
+	}) => {
+		await app.newNote('Spaces');
+		const start = await app.doc();
+		await page.keyboard.type('Hello ');
+		// Let the debounced save run with the trailing space in place.
+		await expectStoredBody(app, 'Spaces.md', `${start}Hello `);
+		await page.keyboard.type(' world  ');
+		await expectStoredBody(app, 'Spaces.md', `${start}Hello  world  `);
+		expect(await app.doc()).toBe(`${start}Hello  world  `);
+		expect(await app.caret()).toBe((await app.doc()).length);
+		await page.keyboard.type('!');
+		expect(await app.doc()).toBe(`${start}Hello  world  !`);
+		await expectStoredBody(app, 'Spaces.md', `${start}Hello  world  !`);
+		expect(await app.messages()).toEqual([]);
+	});
+
+	test('keeps Enter at the end, at the start of a line, and blank lines', async ({
+		app,
+		page,
+	}) => {
+		await app.newNote('Lines');
+		const start = await app.doc();
+		await page.keyboard.type('first');
+		await page.keyboard.press('Enter');
+		await expectStoredBody(app, 'Lines.md', `${start}first\n`);
+		await page.keyboard.press('Enter');
+		await expectStoredBody(app, 'Lines.md', `${start}first\n\n`);
+		await page.keyboard.type('second');
+		await expectStoredBody(app, 'Lines.md', `${start}first\n\nsecond`);
+		// Enter at the start of a line pushes it down.
+		await page.keyboard.press('Home');
+		await page.keyboard.press('Enter');
+		await expectStoredBody(app, 'Lines.md', `${start}first\n\n\nsecond`);
+		expect(await app.doc()).toBe(`${start}first\n\n\nsecond`);
+		await page.keyboard.type('x');
+		expect(await app.doc()).toBe(`${start}first\n\n\nxsecond`);
+		await expectStoredBody(app, 'Lines.md', `${start}first\n\n\nxsecond`);
+		expect(await app.messages()).toEqual([]);
+	});
+
+	test('loses nothing when typing fast across the autosave delays', async ({
+		app,
+		page,
+	}) => {
+		await app.newNote('Fast');
+		const start = await app.doc();
+		let expected = start;
+		// Type steadily for longer than the forced save (2 s), with short
+		// pauses around the 300 ms debounce so saves start mid-typing.
+		for (let round = 0; round < 12; round += 1) {
+			const chunk = `word${round} `;
+			await page.keyboard.type(chunk, { delay: 15 });
+			expected += chunk;
+			if (round % 3 === 2) {
+				await page.keyboard.press('Enter');
+				expected += '\n';
+			}
+			await page.waitForTimeout(round % 2 === 0 ? 320 : 90);
+			expect(await app.doc()).toBe(expected);
+			expect(await app.caret()).toBe(expected.length);
+		}
+		await expectStoredBody(app, 'Fast.md', expected);
+		expect(await app.doc()).toBe(expected);
+		expect(await app.messages()).toEqual([]);
+	});
+
+	test('undo and redo work after saves', async ({ app, page }) => {
+		await app.newNote('Undo');
+		const start = await app.doc();
+		await page.keyboard.type('alpha ');
+		await expectStoredBody(app, 'Undo.md', `${start}alpha `);
+		await page.waitForTimeout(600);
+		await page.keyboard.type('beta');
+		await expectStoredBody(app, 'Undo.md', `${start}alpha beta`);
+		await page.keyboard.press('ControlOrMeta+z');
+		expect(await app.doc()).toBe(`${start}alpha `);
+		await expectStoredBody(app, 'Undo.md', `${start}alpha `);
+		await page.keyboard.press('ControlOrMeta+Shift+KeyZ');
+		expect(await app.doc()).toBe(`${start}alpha beta`);
+		await expectStoredBody(app, 'Undo.md', `${start}alpha beta`);
+		expect(await app.messages()).toEqual([]);
+	});
+
+	test('reloading shows exactly what was typed', async ({ app, page }) => {
+		await app.newNote('Reload');
+		await page.keyboard.type('one  two ');
+		await page.keyboard.press('Enter');
+		await page.keyboard.press('Enter');
+		await page.keyboard.type('  indented');
+		await page.keyboard.press('Enter');
+		await page.keyboard.type('last ');
+		const typed = await app.doc();
+		expect(typed).toBe('one  two \n\n  indented\n  last ');
+		await expectStoredBody(app, 'Reload.md', typed);
+		await page.reload();
+		await app.treeItem('Reload').click();
+		await expect(app.editor()).toBeVisible();
+		expect(await app.doc()).toBe(typed);
+		expect(await app.messages()).toEqual([]);
+	});
+
+	test('an outside edit merges with local typing and says so once', async ({
+		app,
+		page,
+	}) => {
+		await app.newNote('Outside');
+		const start = await app.doc();
+		await page.keyboard.type('local line');
+		await expectStoredBody(app, 'Outside.md', `${start}local line`);
+		const file = (await app.stored('Outside.md'))!;
+		await app.writeOutside(
+			'Outside.md',
+			file.replace('local line\n', 'local line\n\nfrom outside\n'),
+		);
+		await expect.poll(() => app.doc()).toContain('from outside');
+		// Keep typing: the text on screen and the file must keep both edits.
+		await app.caretToEnd();
+		await page.keyboard.type(' more');
+		await expectStoredBody(
+			app,
+			'Outside.md',
+			`${start}local line\n\nfrom outside more`,
+		);
+		expect(await app.doc()).toBe(`${start}local line\n\nfrom outside more`);
+
+		// Typing before the outside edit is saved merges on the next save.
+		await page.keyboard.press('ControlOrMeta+Home');
+		const before = (await app.stored('Outside.md'))!;
+		await page.keyboard.type('X');
+		await app.writeOutside('Outside.md', `${before}tail\n`);
+		await expectStoredBody(
+			app,
+			'Outside.md',
+			`X${start}local line\n\nfrom outside more\ntail`,
+		);
+		await expect
+			.poll(() => app.doc())
+			.toBe(`X${start}local line\n\nfrom outside more\ntail`);
+		expect(await app.messages()).toEqual([MERGED_MESSAGE]);
+	});
+
+	test('Enter in a new note’s name moves to its text at once', async ({
+		app,
+		page,
+	}) => {
+		// The text editor loads while the name is focused. On a slow machine
+		// Enter comes first; the caret must still land in the text.
+		await app.delayEditorLoad(1500);
+		await app.openFiles();
+		await page.getByRole('button', { name: 'New note' }).click();
+		await expect(app.fileName).toBeFocused();
+		await page.keyboard.type('Quick');
+		await page.keyboard.press('Enter');
+		await expect(app.editor()).toBeFocused();
+		await page.keyboard.type('first words');
+		expect(await app.doc()).toBe('first words');
+		await expect.poll(() => app.storedBody('Quick.md')).toBe('first words\n');
+	});
+});
diff --git a/apps/app/tests/e2e/file-tree.e2e.ts b/apps/app/tests/e2e/file-tree.e2e.ts
new file mode 100644
index 0000000..f4c4561
--- /dev/null
+++ b/apps/app/tests/e2e/file-tree.e2e.ts
@@ -0,0 +1,236 @@
+import { expect, noteFileBody, test, type App } from './fixtures';
+
+/**
+ * Create a note or folder from the tree's context menu: on `parent`, or on
+ * the blank space below the rows for the workspace root.
+ */
+async function create(
+	app: App,
+	kind: 'note' | 'folder',
+	name: string,
+	parent?: string,
+) {
+	const page = app.page;
+	await app.openFiles();
+	if (parent) {
+		await app.treeItem(parent).click({ button: 'right' });
+	} else {
+		const rows = page.getByRole('tree', { name: 'Files' });
+		const area = (
+			(await rows.count()) > 0 ? rows : page.getByText('This folder is empty.')
+		).locator('..');
+		const box = (await area.boundingBox())!;
+		await area.click({
+			button: 'right',
+			position: { x: 30, y: box.height - 6 },
+		});
+	}
+	await page
+		.getByRole('menuitem', {
+			name: kind === 'note' ? 'New note' : 'New folder',
+		})
+		.click();
+	const input =
+		kind === 'note'
+			? app.fileName
+			: page.getByRole('textbox', { name: /^New name for / });
+	await expect(input).toBeFocused();
+	await page.keyboard.press('ControlOrMeta+a');
+	await page.keyboard.type(name);
+	await page.keyboard.press('Enter');
+	await expect(app.treeItem(name)).toBeVisible();
+	if (kind === 'note') await expect(app.editor()).toBeFocused();
+}
+
+/** A note at the workspace root holding `text`. */
+async function writeNote(app: App, name: string, text: string) {
+	await create(app, 'note', name);
+	await app.page.keyboard.type(text);
+	await expect
+		.poll(() => app.storedBody(`${name}.md`))
+		.toBe(noteFileBody(text));
+}
+
+test.describe('file tree', () => {
+	test('creates notes and folders at the root and inside a folder', async ({
+		app,
+		page,
+	}) => {
+		await create(app, 'folder', 'Projects');
+		await create(app, 'note', 'Inside', 'Projects');
+		await create(app, 'folder', 'Nested', 'Projects');
+		await create(app, 'note', 'Deep', 'Nested');
+		await create(app, 'note', 'Root note');
+		await create(app, 'folder', 'Top');
+		// The New note button uses the folder of the selected row.
+		await app.treeItem('Inside').click();
+		await page.getByRole('button', { name: 'New note' }).click();
+		await expect(app.fileName).toBeFocused();
+		await page.keyboard.type('Sibling');
+		await page.keyboard.press('Enter');
+		await expect
+			.poll(() => app.storedPaths())
+			.toEqual([
+				'Projects',
+				'Projects/Inside.md',
+				'Projects/Nested',
+				'Projects/Nested/Deep.md',
+				'Projects/Sibling.md',
+				'Root note.md',
+				'Top',
+			]);
+	});
+
+	test('F2 renames in the tree, including a change of case only', async ({
+		app,
+		page,
+	}) => {
+		await writeNote(app, 'draft', 'body text');
+		await app.treeItem('draft').focus();
+		await page.keyboard.press('F2');
+		const input = page.getByRole('textbox', { name: 'New name for draft' });
+		await expect(input).toBeFocused();
+		await page.keyboard.type('Final');
+		await page.keyboard.press('Enter');
+		await expect(app.treeItem('Final')).toBeVisible();
+		await expect(app.fileName).toHaveValue('Final');
+		await app.treeItem('Final').focus();
+		await page.keyboard.press('F2');
+		await page.keyboard.type('FINAL');
+		await page.keyboard.press('Enter');
+		await expect(app.treeItem('FINAL')).toBeVisible();
+		await expect(app.fileName).toHaveValue('FINAL');
+		await expect.poll(() => app.storedPaths()).toContain('FINAL.md');
+		expect(await app.storedPaths()).not.toContain('Final.md');
+		expect(await app.storedBody('FINAL.md')).toBe(noteFileBody('body text'));
+		expect(await app.doc()).toBe('body text');
+	});
+
+	test('F2 renames the open file after clicking it in the tree', async ({
+		app,
+		page,
+	}) => {
+		await writeNote(app, 'Clicked', 'keep this text');
+		await app.newNote('Other');
+		await app.treeItem('Clicked').click();
+		await expect(app.fileName).toHaveValue('Clicked');
+		await page.keyboard.press('F2');
+		await expect(app.fileName).toBeFocused();
+		// The whole name is selected, so typing replaces it.
+		await page.keyboard.type('Renamed');
+		await page.keyboard.press('Enter');
+		await expect(app.treeItem('Renamed')).toBeVisible();
+		await expect.poll(() => app.storedPaths()).toContain('Renamed.md');
+		expect(await app.storedBody('Renamed.md')).toBe(
+			noteFileBody('keep this text'),
+		);
+		expect(await app.doc()).toBe('keep this text');
+	});
+
+	test('drag and drop moves a note into a folder and keeps it open', async ({
+		app,
+		page,
+	}) => {
+		await writeNote(app, 'Moving', 'moved text');
+		await create(app, 'folder', 'Archive');
+		await app.treeItem('Moving').click();
+		await app.treeItem('Moving').dragTo(app.treeItem('Archive'));
+		await expect.poll(() => app.storedPaths()).toContain('Archive/Moving.md');
+		await expect(app.treeItem('Moving')).toHaveAttribute('aria-level', '2');
+		await page.keyboard.press('ControlOrMeta+End');
+		expect(await app.doc()).toBe('moved text');
+		await app.editor().focus();
+		await page.keyboard.press('ControlOrMeta+End');
+		await page.keyboard.type(' more');
+		await expect
+			.poll(() => app.storedBody('Archive/Moving.md'))
+			.toBe(noteFileBody('moved text more'));
+		expect(await app.storedPaths()).not.toContain('Moving.md');
+	});
+
+	test('duplicate copies a note', async ({ app, page }) => {
+		await writeNote(app, 'Original', 'copy me');
+		await app.treeItem('Original').click({ button: 'right' });
+		await page.getByRole('menuitem', { name: 'Duplicate' }).click();
+		await expect.poll(() => app.storedPaths()).toHaveLength(2);
+		const copy = (await app.storedPaths()).find(
+			(path) => path !== 'Original.md',
+		)!;
+		expect(await app.storedBody(copy)).toBe(noteFileBody('copy me'));
+		const original = await app.stored('Original.md');
+		const duplicate = await app.stored(copy);
+		// The copy is a new object with its own ID.
+		expect(duplicate!.match(/^id: (.*)$/m)?.[1]).not.toBe(
+			original!.match(/^id: (.*)$/m)?.[1],
+		);
+	});
+
+	test('trashing the open note closes its editor and its tab', async ({
+		app,
+		page,
+	}) => {
+		await writeNote(app, 'Keep', 'kept');
+		await writeNote(app, 'Doomed', 'unsaved soon');
+		await page.keyboard.type(' last words');
+		await app.treeItem('Doomed').click({ button: 'right' });
+		await page.getByRole('menuitem', { name: 'Move to Trash' }).click();
+		await expect(app.treeItem('Doomed')).toBeHidden();
+		await expect(
+			page.getByRole('tab', { name: 'Doomed', exact: true }),
+		).toBeHidden();
+		// The tab that takes its place is the document on screen.
+		const selected = page.getByRole('tab', { selected: true });
+		await expect(selected).toHaveText('Keep');
+		await expect(app.fileName).toHaveValue('Keep');
+		expect(await app.doc()).toBe('kept');
+		await expect.poll(() => app.storedPaths()).toEqual(['Keep.md']);
+
+		// Trashing the last open document leaves nothing open or highlighted.
+		await app.treeItem('Keep').click({ button: 'right' });
+		await page.getByRole('menuitem', { name: 'Move to Trash' }).click();
+		await expect(page.getByText('No file open')).toBeVisible();
+		await expect(page.getByRole('tab', { selected: true })).toHaveCount(0);
+		await expect(app.editor()).toBeHidden();
+	});
+
+	test('keyboard navigation opens files and folders', async ({ app, page }) => {
+		await writeNote(app, 'Beta', 'beta text');
+		await writeNote(app, 'Gamma', 'gamma text');
+		await create(app, 'folder', 'Alpha');
+		await app.treeItem('Alpha').focus();
+		await page.keyboard.press('ArrowDown');
+		await expect(app.treeItem('Beta')).toBeFocused();
+		await page.keyboard.press('Enter');
+		await expect(app.fileName).toHaveValue('Beta');
+		await app.treeItem('Beta').focus();
+		await page.keyboard.press('End');
+		await expect(app.treeItem('Gamma')).toBeFocused();
+		await page.keyboard.press('Home');
+		await expect(app.treeItem('Alpha')).toBeFocused();
+		await page.keyboard.press('g');
+		await expect(app.treeItem('Gamma')).toBeFocused();
+		await page.keyboard.press(' ');
+		await expect(app.fileName).toHaveValue('Gamma');
+	});
+
+	test('expanded folders stay expanded after a reload', async ({
+		app,
+		page,
+	}) => {
+		await create(app, 'folder', 'Open');
+		await create(app, 'folder', 'Closed');
+		await create(app, 'note', 'Child', 'Open');
+		await expect(app.treeItem('Open')).toHaveAttribute('aria-expanded', 'true');
+		await expect(app.treeItem('Closed')).toHaveAttribute(
+			'aria-expanded',
+			'false',
+		);
+		await page.goto('/files');
+		await expect(app.treeItem('Open')).toHaveAttribute('aria-expanded', 'true');
+		await expect(app.treeItem('Child')).toBeVisible();
+		await expect(app.treeItem('Closed')).toHaveAttribute(
+			'aria-expanded',
+			'false',
+		);
+	});
+});
diff --git a/apps/app/tests/e2e/fixtures.ts b/apps/app/tests/e2e/fixtures.ts
new file mode 100644
index 0000000..3ded531
--- /dev/null
+++ b/apps/app/tests/e2e/fixtures.ts
@@ -0,0 +1,357 @@
+import { readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import {
+	test as base,
+	expect,
+	type Locator,
+	type Page,
+} from '@playwright/test';
+
+export { expect };
+
+export const MERGED_MESSAGE = 'Merged changes from another app';
+
+/**
+ * How a note stores the text typed into it: line breaks around the text are
+ * normalized and the file ends with one; everything else is kept as typed.
+ */
+export function noteFileBody(typed: string): string {
+	const body = typed.replace(/^\n+/, '').replace(/[\r\n]+$/, '');
+	return body.trim() ? `${body}\n` : '';
+}
+
+/**
+ * The built workspace worker, so tests can open a second one. Looked up
+ * when first needed: the web server builds the app after tests load.
+ */
+function workerUrl(): string | null {
+	const directory = fileURLToPath(
+		new URL('../../build/_app/immutable/workers/', import.meta.url),
+	);
+	let name: string | undefined;
+	try {
+		name = readdirSync(directory).find(
+			(file) =>
+				file.startsWith('browser-workspace.worker') && file.endsWith('.js'),
+		);
+	} catch {
+		name = undefined;
+	}
+	return name ? `/_app/immutable/workers/${name}` : null;
+}
+
+declare global {
+	interface Window {
+		__e2e?: {
+			messages: string[];
+			outside?: (command: string, payload?: object) => Promise<unknown>;
+		};
+	}
+}
+
+/**
+ * Records every time a watched message appears, so a test can prove a
+ * message that shows for two seconds never showed at all.
+ */
+function recordMessages(watched: string[]) {
+	const state = { messages: [] as string[] };
+	window.__e2e = state;
+	const visible = new Set<string>();
+	const check = () => {
+		const text = document.body?.innerText ?? '';
+		for (const message of watched) {
+			const shown = text.includes(message);
+			if (shown && !visible.has(message)) state.messages.push(message);
+			if (shown) visible.add(message);
+			else visible.delete(message);
+		}
+	};
+	new MutationObserver(check).observe(document, {
+		subtree: true,
+		childList: true,
+		characterData: true,
+	});
+}
+
+export class App {
+	constructor(readonly page: Page) {}
+
+	/** The note or Markdown text editor. */
+	editor(name = 'Note text'): Locator {
+		return this.page.getByRole('textbox', { name, exact: true });
+	}
+
+	get fileName(): Locator {
+		return this.page.getByRole('textbox', { name: 'File name' });
+	}
+
+	get tree(): Locator {
+		return this.page.getByRole('tree', { name: 'Files' });
+	}
+
+	treeItem(name: string | RegExp): Locator {
+		return this.tree.getByRole('treeitem', { name, exact: true });
+	}
+
+	async createWorkspace(name = 'E2E') {
+		await this.page.goto('/');
+		await this.page.getByLabel('New workspace').fill(name);
+		await this.page.getByRole('button', { name: 'Create' }).click();
+		await expect(
+			this.page.getByRole('navigation', { name: 'Sections' }),
+		).toBeVisible();
+	}
+
+	async openFiles() {
+		await this.page
+			.getByRole('navigation', { name: 'Sections' })
+			.getByRole('link', { name: 'Files' })
+			.click();
+		await expect(
+			this.page.getByRole('button', { name: 'New note' }),
+		).toBeVisible();
+	}
+
+	/** Create a note with New note, name it, and put the caret in its text. */
+	async newNote(name: string) {
+		await this.openFiles();
+		await this.page.getByRole('button', { name: 'New note' }).click();
+		// Move the pointer off the button, as a person would, so its tooltip
+		// does not stay open over the first row of the tree.
+		await this.page.mouse.move(700, 450);
+		await expect(this.fileName).toBeFocused();
+		await this.page.keyboard.press('ControlOrMeta+a');
+		await this.page.keyboard.type(name);
+		await this.page.keyboard.press('Enter');
+		await expect(this.editor()).toBeFocused();
+		await expect(this.treeItem(name)).toBeVisible();
+	}
+
+	/** The text the editor holds, which may differ from what it renders. */
+	async doc(name = 'Note text'): Promise<string> {
+		return this.editor(name).evaluate((element) => {
+			const tile = (element as unknown as { cmTile?: EditorTile }).cmTile;
+			const view = tile?.root?.view;
+			if (!view) throw new Error('No editor view');
+			return view.state.doc.toString();
+		});
+	}
+
+	/** Caret offset in the editor's text. */
+	async caret(name = 'Note text'): Promise<number> {
+		return this.editor(name).evaluate((element) => {
+			const tile = (element as unknown as { cmTile?: EditorTile }).cmTile;
+			const view = tile?.root?.view;
+			if (!view) throw new Error('No editor view');
+			return view.state.selection.main.head;
+		});
+	}
+
+	/** Put the caret at the end of the text with the keyboard. */
+	async caretToEnd(name = 'Note text') {
+		await this.editor(name).focus();
+		await this.page.keyboard.press('ControlOrMeta+End');
+	}
+
+	/**
+	 * Put the caret right after the first `anchor` in the text. Rendered
+	 * tables and code blocks make arrow keys and clicks land unpredictably,
+	 * so this sets the selection directly; typing still uses the keyboard.
+	 */
+	async caretAfter(anchor: string, name = 'Note text') {
+		await this.editor(name).focus();
+		await this.editor(name).evaluate((element, anchor) => {
+			const tile = (element as unknown as { cmTile?: EditorTile }).cmTile;
+			const view = tile?.root?.view;
+			if (!view) throw new Error('No editor view');
+			const offset = view.state.doc.toString().indexOf(anchor);
+			if (offset < 0) throw new Error(`No “${anchor}” in the editor`);
+			view.dispatch({ selection: { anchor: offset + anchor.length } });
+		}, anchor);
+	}
+
+	/** Messages from `recordMessages` seen so far. */
+	async messages(): Promise<string[]> {
+		return this.page.evaluate(() => [...(window.__e2e?.messages ?? [])]);
+	}
+
+	async #outside<T>(command: string, payload: object = {}): Promise<T> {
+		const url = workerUrl();
+		if (!url)
+			throw new Error('Build the app first: the workspace worker is missing');
+		return (await this.page.evaluate(
+			async ({ url, command, payload }) => {
+				const state = window.__e2e!;
+				if (!state.outside) {
+					const worker = new Worker(url, { type: 'module' });
+					const pending = new Map<
+						string,
+						{ resolve(value: unknown): void; reject(error: Error): void }
+					>();
+					let next = 0;
+					await new Promise<void>((resolve, reject) => {
+						worker.addEventListener('message', (event) => {
+							const data = event.data;
+							if (data?.type === 'ready') resolve();
+							else if (data?.type === 'startup-error')
+								reject(new Error('The second worker did not start'));
+							else if (data?.type === 'response') {
+								const request = pending.get(data.id);
+								pending.delete(data.id);
+								if (data.ok) request?.resolve(data.value);
+								else request?.reject(new Error(JSON.stringify(data.error)));
+							}
+						});
+					});
+					const request = (command: string, payload: object = {}) =>
+						new Promise<unknown>((resolve, reject) => {
+							const id = `outside-${next++}`;
+							pending.set(id, { resolve, reject });
+							worker.postMessage({ type: 'request', id, command, payload });
+						});
+					const id = localStorage.getItem('noura.browser.last-workspace');
+					await request('workspace_open', {
+						input: { path: `browser://${id}` },
+					});
+					state.outside = request;
+				}
+				return state.outside(command, payload);
+			},
+			{ url, command, payload },
+		)) as T;
+	}
+
+	/**
+	 * The bytes stored for `path`, read through a second workspace worker,
+	 * as another tab would. Null when the file does not exist.
+	 */
+	async stored(path: string): Promise<string | null> {
+		const file = await this.#outside<{ bytes: string } | null>(
+			'storage_files_read',
+			{ path },
+		);
+		if (!file) return null;
+		return Buffer.from(file.bytes, 'base64').toString('utf8');
+	}
+
+	/**
+	 * The body of a stored note: the bytes after its noura header and its
+	 * `# Title` line, exactly as stored.
+	 */
+	async storedBody(path: string): Promise<string | null> {
+		const text = await this.stored(path);
+		if (text === null) return null;
+		const match = /^---\n[\s\S]*?\n---\n\n?# [^\n]*\n\n?/.exec(text);
+		if (!match) throw new Error(`${path} is not a note:\n${text}`);
+		return text.slice(match[0].length);
+	}
+
+	/** Write `text` to `path` from outside this tab, like another app would. */
+	async writeOutside(path: string, text: string | Uint8Array) {
+		const current = await this.#outside<{ revision: string } | null>(
+			'storage_files_read',
+			{ path },
+		);
+		const bytes =
+			typeof text === 'string' ? Buffer.from(text, 'utf8') : Buffer.from(text);
+		await this.#outside('storage_files_write', {
+			path,
+			bytes: bytes.toString('base64'),
+			expectedRevision: current?.revision ?? null,
+		});
+	}
+
+	/** Serve the text editor's code `ms` late, like a slow machine. */
+	async delayEditorLoad(ms: number) {
+		const directory = fileURLToPath(
+			new URL('../../build/_app/immutable/chunks/', import.meta.url),
+		);
+		const chunks = readdirSync(directory).filter((file) =>
+			readFileSync(join(directory, file), 'utf8').includes('cm-md-checkbox'),
+		);
+		if (chunks.length === 0) throw new Error('No editor chunk in the build');
+		for (const chunk of chunks)
+			await this.page.route(
+				`**/_app/immutable/chunks/${chunk}`,
+				async (route) => {
+					await new Promise((resolve) => setTimeout(resolve, ms));
+					await route.continue();
+				},
+			);
+	}
+
+	/**
+	 * Hold the workspace storage lock, so saves stay in flight until
+	 * `release` runs, like a slow disk.
+	 */
+	async holdStorage(): Promise<() => Promise<void>> {
+		await this.page.evaluate(
+			(name) =>
+				new Promise<void>((held) => {
+					void navigator.locks.request(
+						name,
+						{ mode: 'exclusive' },
+						() =>
+							new Promise<void>((release) => {
+								(window as unknown as { __release?: () => void }).__release =
+									release;
+								held();
+							}),
+					);
+				}),
+			await this.#storageLock(),
+		);
+		return async () => {
+			await this.page.evaluate(() =>
+				(window as unknown as { __release?: () => void }).__release?.(),
+			);
+		};
+	}
+
+	/** True while a request is waiting for the storage lock. */
+	async storageWaiting(): Promise<boolean> {
+		return this.page.evaluate(
+			async (name) => {
+				const state = await navigator.locks.query();
+				return (state.pending ?? []).some((lock) => lock.name === name);
+			},
+			await this.#storageLock(),
+		);
+	}
+
+	/** The Web Lock the open workspace's storage operations take. */
+	#storageLock(): Promise<string> {
+		return this.page.evaluate(
+			() =>
+				`noura:browser-workspace:${localStorage.getItem('noura.browser.last-workspace')}`,
+		);
+	}
+
+	async storedPaths(): Promise<string[]> {
+		const entries =
+			await this.#outside<Array<{ relativePath: string }>>('files_list');
+		return entries.map((entry) => entry.relativePath).sort();
+	}
+}
+
+type EditorTile = {
+	root?: {
+		view?: {
+			state: {
+				doc: { toString(): string };
+				selection: { main: { head: number } };
+			};
+			dispatch(spec: { selection: { anchor: number } }): void;
+		};
+	};
+};
+
+export const test = base.extend<{ app: App }>({
+	app: async ({ page }, use) => {
+		await page.addInitScript(recordMessages, [MERGED_MESSAGE]);
+		const app = new App(page);
+		await app.createWorkspace();
+		await use(app);
+	},
+});
diff --git a/apps/app/tests/e2e/layout.e2e.ts b/apps/app/tests/e2e/layout.e2e.ts
new file mode 100644
index 0000000..80a9611
--- /dev/null
+++ b/apps/app/tests/e2e/layout.e2e.ts
@@ -0,0 +1,84 @@
+import { expect, test } from './fixtures';
+
+test.describe('layout at a normal window width', () => {
+	test.use({ viewport: { width: 1100, height: 750 } });
+
+	test('the task pane shows its whole toolbar and readable values', async ({
+		app,
+		page,
+	}) => {
+		await page.goto('/tasks?view=all');
+		await page.getByRole('button', { name: 'New task' }).click();
+		const toolbar = page.getByRole('toolbar', { name: 'Formatting' });
+		await expect(toolbar).toBeVisible();
+		const overflow = await toolbar.evaluate(
+			(element) => element.scrollWidth - element.clientWidth,
+		);
+		expect(overflow).toBeLessThanOrEqual(0);
+		await expect(
+			toolbar.getByRole('button', { name: /Find and replace/ }),
+		).toBeInViewport({ ratio: 1 });
+		await expect(page.getByLabel('Status', { exact: true })).toHaveText(
+			'To do',
+		);
+		await expect(page.getByLabel('Priority', { exact: true })).toHaveText(
+			'Medium',
+		);
+		await page.getByLabel('Status', { exact: true }).click();
+		await expect(page.getByRole('option')).toHaveText([
+			'To do',
+			'In progress',
+			'Done',
+			'Cancelled',
+		]);
+		await page.keyboard.press('Escape');
+		expect(await app.storedPaths()).toHaveLength(2);
+	});
+
+	test('tabs fit the title bar row with no scrollbar and still scroll', async ({
+		app,
+		page,
+	}) => {
+		for (let index = 1; index <= 12; index += 1)
+			await app.newNote(`A long note name ${index}`);
+		await page
+			.getByRole('navigation', { name: 'Sections' })
+			.getByRole('link', { name: 'Home' })
+			.click();
+		const bar = page.getByRole('tablist', { name: 'Open files' });
+		const box = await bar.evaluate((element: HTMLElement) => {
+			const header = document.querySelector('header')!.getBoundingClientRect();
+			const rect = element.getBoundingClientRect();
+			const tab = element
+				.querySelector('[role="tab"]')!
+				.getBoundingClientRect();
+			return {
+				top: rect.top,
+				bottom: rect.bottom,
+				headerBottom: header.bottom,
+				scrollbar:
+					element.offsetHeight -
+					element.clientHeight -
+					parseFloat(getComputedStyle(element).borderBottomWidth),
+				// Some systems draw overlay scrollbars that take no space.
+				hidden: getComputedStyle(element).scrollbarWidth === 'none',
+				overflowing: element.scrollWidth > element.clientWidth,
+				tabTop: tab.top,
+				tabBottom: tab.bottom,
+			};
+		});
+		expect(box.top).toBe(0);
+		expect(box.bottom).toBe(box.headerBottom);
+		expect(box.scrollbar).toBe(0);
+		expect(box.hidden).toBe(true);
+		expect(box.overflowing).toBe(true);
+		expect(box.tabTop).toBeGreaterThan(box.top);
+		expect(box.tabBottom).toBeLessThan(box.bottom);
+		// A mouse wheel scrolls the tabs sideways.
+		await bar.hover();
+		await page.mouse.wheel(0, 400);
+		await expect
+			.poll(() => bar.evaluate((element) => element.scrollLeft))
+			.toBeGreaterThan(0);
+	});
+});
diff --git a/apps/app/tests/e2e/markdown-files.e2e.ts b/apps/app/tests/e2e/markdown-files.e2e.ts
new file mode 100644
index 0000000..145fc63
--- /dev/null
+++ b/apps/app/tests/e2e/markdown-files.e2e.ts
@@ -0,0 +1,175 @@
+import { expect, MERGED_MESSAGE, test, type App } from './fixtures';
+
+const RICH = [
+	'---',
+	'title: Plain file',
+	'tags: [one, two]',
+	'---',
+	'',
+	'# Plain file',
+	'',
+	'Intro with trailing spaces  ',
+	'',
+	'| Name | Value |',
+	'| ---- | ----: |',
+	'| a    |     1 |',
+	'',
+	'```ts',
+	'const a = 1;',
+	'```',
+	'',
+	'> [!note] Callout title',
+	'> Callout body',
+	'',
+	'- [ ] open task',
+	'- [x] done task',
+	'',
+	'See [[Other note]] and [[Other note|alias]].',
+	'',
+	'Edit here',
+	'',
+].join('\n');
+
+/** Open a plain Markdown file another app put in the workspace. */
+async function openPlainFile(
+	app: App,
+	path: string,
+	text: string | Uint8Array,
+) {
+	await app.openFiles();
+	await app.writeOutside(path, text);
+	const name = path.replace(/\.md$/, '');
+	await app.treeItem(name).click();
+	await expect(app.editor('File text')).toBeVisible();
+}
+
+/** Type `insert` right after `anchor`. */
+async function typeAfter(app: App, anchor: string, insert: string) {
+	await app.caretAfter(anchor, 'File text');
+	await app.page.keyboard.type(insert);
+}
+
+test.describe('plain Markdown files', () => {
+	test('editing keeps every other byte of the file', async ({ app, page }) => {
+		await openPlainFile(app, 'Plain.md', RICH);
+		await typeAfter(app, 'Edit here', ' and there ');
+		const expected = RICH.replace('Edit here', 'Edit here and there ');
+		await expect.poll(() => app.stored('Plain.md')).toBe(expected);
+		await page.reload();
+		await app.treeItem('Plain').click();
+		await expect(app.editor('File text')).toBeVisible();
+		expect(await app.doc('File text')).toBe(expected);
+		expect(await app.stored('Plain.md')).toBe(expected);
+		expect(await app.messages()).toEqual([]);
+	});
+
+	test('CRLF line endings and a byte order mark survive an edit', async ({
+		app,
+	}) => {
+		const crlf = RICH.replaceAll('\n', '\r\n');
+		const bytes = new Uint8Array([
+			0xef,
+			0xbb,
+			0xbf,
+			...new TextEncoder().encode(crlf),
+		]);
+		await openPlainFile(app, 'Windows.md', bytes);
+		expect(await app.doc('File text')).toBe(RICH);
+		await typeAfter(app, 'Edit here', '!');
+		const expected = `${crlf.replace('Edit here', 'Edit here!')}`;
+		await expect.poll(() => app.stored('Windows.md')).toBe(expected);
+		expect(await app.messages()).toEqual([]);
+	});
+
+	test('typing at the end of a file without a final newline', async ({
+		app,
+		page,
+	}) => {
+		await openPlainFile(app, 'Bare.md', 'no newline');
+		await app.caretToEnd('File text');
+		await page.keyboard.type(' ');
+		await expect.poll(() => app.stored('Bare.md')).toBe('no newline ');
+		await page.keyboard.press('Enter');
+		await expect.poll(() => app.stored('Bare.md')).toBe('no newline \n');
+		await page.keyboard.press('Enter');
+		await page.keyboard.type('x');
+		await expect.poll(() => app.stored('Bare.md')).toBe('no newline \n\nx');
+		expect(await app.doc('File text')).toBe('no newline \n\nx');
+		expect(await app.messages()).toEqual([]);
+	});
+
+	test('an outside edit made during typing is merged, shown, and kept', async ({
+		app,
+		page,
+	}) => {
+		await openPlainFile(app, 'Shared.md', 'first\n\nsecond\n\nthird\n');
+		await typeAfter(app, 'first', ' local');
+		await expect
+			.poll(() => app.stored('Shared.md'))
+			.toBe('first local\n\nsecond\n\nthird\n');
+		// The outside edit lands before the debounced save of ' more' runs.
+		await page.keyboard.type(' more');
+		await app.writeOutside(
+			'Shared.md',
+			'first local\n\nsecond\n\nthird outside\n',
+		);
+		await expect
+			.poll(() => app.stored('Shared.md'))
+			.toBe('first local more\n\nsecond\n\nthird outside\n');
+		await expect
+			.poll(() => app.doc('File text'))
+			.toBe('first local more\n\nsecond\n\nthird outside\n');
+		// A later save keeps the outside edit.
+		await page.keyboard.type('!');
+		await expect
+			.poll(() => app.stored('Shared.md'))
+			.toBe('first local more!\n\nsecond\n\nthird outside\n');
+		expect(await app.messages()).toEqual([MERGED_MESSAGE]);
+	});
+});
+
+test.describe('notes written by another app', () => {
+	test('editing a note keeps its other properties and text', async ({
+		app,
+		page,
+	}) => {
+		const header = [
+			'---',
+			'id: note_01j00000000000000000000001',
+			'type: note',
+			'aliases:',
+			'- Plan',
+			'rating: 4',
+			'source: https://example.com/a?b=c',
+			'tags:',
+			'- work',
+			'- q3',
+			'created: 2026-09-01T10:00:00Z',
+			'updated: 2026-09-01T10:00:00Z',
+			'---',
+			// Notes put a blank line after the header, as the format writes it.
+			'',
+			'',
+		].join('\n');
+		const body = RICH.slice(RICH.indexOf('# Plain file'))
+			.replace('# Plain file', '# Imported')
+			.replace(/\n$/, '');
+		await app.openFiles();
+		await app.writeOutside('Imported.md', `${header}${body}\n`);
+		await app.treeItem('Imported').click();
+		await expect(app.fileName).toHaveValue('Imported');
+		const shown = await app.doc();
+		await app.caretAfter('Edit here');
+		await page.keyboard.type(' now');
+		await expect
+			.poll(() => app.stored('Imported.md'))
+			.toContain('Edit here now');
+		const stored = (await app.stored('Imported.md'))!;
+		// Only the edit and the updated time differ.
+		const expected = `${header}${body}\n`
+			.replace('Edit here', 'Edit here now')
+			.replace(/^updated: .*$/m, stored.match(/^updated: .*$/m)![0]);
+		expect(stored).toBe(expected);
+		expect(await app.doc()).toBe(shown.replace('Edit here', 'Edit here now'));
+	});
+});
diff --git a/apps/app/tests/e2e/navigation.e2e.ts b/apps/app/tests/e2e/navigation.e2e.ts
new file mode 100644
index 0000000..918690f
--- /dev/null
+++ b/apps/app/tests/e2e/navigation.e2e.ts
@@ -0,0 +1,328 @@
+import { expect, noteFileBody, test, type App } from './fixtures';
+
+async function writeNote(app: App, name: string, text: string) {
+	await app.newNote(name);
+	await app.page.keyboard.type(text);
+	await expect
+		.poll(() => app.storedBody(`${name}.md`))
+		.toBe(noteFileBody(text));
+}
+
+function tab(app: App, name: string) {
+	return app.page.getByRole('tab', { name, exact: true });
+}
+
+test.describe('document header', () => {
+	test('renames the file from its title', async ({ app, page }) => {
+		await writeNote(app, 'Old name', 'content stays');
+		await app.fileName.click();
+		await page.keyboard.press('ControlOrMeta+a');
+		await page.keyboard.type('New name');
+		await page.keyboard.press('Enter');
+		await expect(app.editor()).toBeFocused();
+		await expect(app.treeItem('New name')).toBeVisible();
+		await expect(tab(app, 'New name')).toBeVisible();
+		await expect.poll(() => app.storedPaths()).toEqual(['New name.md']);
+		expect(await app.storedBody('New name.md')).toBe(
+			noteFileBody('content stays'),
+		);
+		expect(await app.stored('New name.md')).toContain('\n# New name\n');
+		// Typing right after the rename saves to the new file.
+		await page.keyboard.press('ControlOrMeta+End');
+		await page.keyboard.type(' more');
+		await expect
+			.poll(() => app.storedBody('New name.md'))
+			.toBe(noteFileBody('content stays more'));
+	});
+
+	test('a name that is taken or empty keeps the old name', async ({
+		app,
+		page,
+	}) => {
+		await writeNote(app, 'Taken', 'first');
+		await writeNote(app, 'Mine', 'second');
+		await app.fileName.click();
+		await page.keyboard.press('ControlOrMeta+a');
+		await page.keyboard.type('Taken');
+		await page.keyboard.press('Enter');
+		await expect(page.getByText(/already/i).first()).toBeVisible();
+		await expect(app.fileName).toHaveValue('Mine');
+		await app.fileName.click();
+		await page.keyboard.press('ControlOrMeta+a');
+		await page.keyboard.press('Backspace');
+		await page.keyboard.press('Enter');
+		await expect(app.fileName).toHaveValue('Mine');
+		expect(await app.storedPaths()).toEqual(['Mine.md', 'Taken.md']);
+		expect(await app.storedBody('Taken.md')).toBe(noteFileBody('first'));
+		expect(await app.storedBody('Mine.md')).toBe(noteFileBody('second'));
+	});
+});
+
+test.describe('tabs', () => {
+	test('a click opens a preview tab that the next click replaces', async ({
+		app,
+		page,
+	}) => {
+		await writeNote(app, 'One', 'one');
+		await writeNote(app, 'Two', 'two');
+		await writeNote(app, 'Three', 'three');
+		// New notes open as kept tabs.
+		await expect(page.getByRole('tab')).toHaveCount(3);
+		await tab(app, 'One').click();
+		await page.getByRole('button', { name: 'Close One' }).click();
+		await page.getByRole('button', { name: 'Close Two' }).click();
+		await expect(page.getByRole('tab')).toHaveText(['Three']);
+		await app.treeItem('One').click();
+		await expect(tab(app, 'One')).toHaveAttribute('title', 'One (preview)');
+		await app.treeItem('Two').click();
+		await expect(tab(app, 'One')).toBeHidden();
+		await expect(tab(app, 'Two')).toHaveAttribute('title', 'Two (preview)');
+		// Typing in a preview keeps it.
+		await app.editor().focus();
+		await page.keyboard.press('ControlOrMeta+End');
+		await page.keyboard.type('!');
+		await expect(tab(app, 'Two')).toHaveAttribute('title', 'Two');
+		// A double-click in the tree opens a kept tab.
+		await app.treeItem('One').dblclick();
+		await expect(tab(app, 'One')).toHaveAttribute('title', 'One');
+		await expect(page.getByRole('tab')).toHaveText(['Three', 'Two', 'One']);
+		// Middle-click closes a tab.
+		await tab(app, 'Three').click({ button: 'middle' });
+		await expect(page.getByRole('tab')).toHaveText(['Two', 'One']);
+		await expect(app.fileName).toHaveValue('One');
+	});
+
+	test('tabs come back after a reload', async ({ app, page }) => {
+		await writeNote(app, 'Left', 'left');
+		await writeNote(app, 'Right', 'right');
+		await tab(app, 'Left').click();
+		await expect(app.fileName).toHaveValue('Left');
+		await page.reload();
+		await expect(page.getByRole('tab')).toHaveText(['Left', 'Right']);
+		await expect(page.getByRole('tab', { selected: true })).toHaveText('Left');
+		await expect(app.fileName).toHaveValue('Left');
+		expect(await app.doc()).toBe('left');
+		await tab(app, 'Right').click();
+		await expect(app.fileName).toHaveValue('Right');
+		expect(await app.doc()).toBe('right');
+	});
+
+	test('switching tabs keeps each note’s text', async ({ app, page }) => {
+		await writeNote(app, 'First', 'alpha');
+		await writeNote(app, 'Second', 'beta');
+		await page.keyboard.type(' typed');
+		// Switch before the autosave delay passes.
+		await tab(app, 'First').click();
+		await expect(app.fileName).toHaveValue('First');
+		expect(await app.doc()).toBe('alpha');
+		await tab(app, 'Second').click();
+		await expect(app.fileName).toHaveValue('Second');
+		expect(await app.doc()).toBe('beta typed');
+		await expect
+			.poll(() => app.storedBody('Second.md'))
+			.toBe(noteFileBody('beta typed'));
+	});
+});
+
+test.describe('finding files', () => {
+	test('quick open finds a note by name and Enter opens the best match', async ({
+		app,
+		page,
+	}) => {
+		await writeNote(app, 'Meeting notes', 'agenda');
+		await writeNote(app, 'Groceries', 'milk');
+		await writeNote(app, 'Meeting archive', 'old');
+		await page.keyboard.press('ControlOrMeta+o');
+		const palette = page.getByRole('dialog', { name: 'Search and commands' });
+		await expect(palette).toBeVisible();
+		await page.keyboard.type('groc');
+		await expect(
+			palette.getByRole('option', { name: /Groceries/ }),
+		).toBeVisible();
+		await page.keyboard.press('Enter');
+		await expect(palette).toBeHidden();
+		await expect(app.fileName).toHaveValue('Groceries');
+		// Typing and pressing Enter at once opens the match, not "New note".
+		await app.treeItem('Groceries').click();
+		await page.keyboard.press('ControlOrMeta+o');
+		await expect(palette).toBeVisible();
+		await page.keyboard.type('meeting n');
+		await page.keyboard.press('Enter');
+		await expect(palette).toBeHidden();
+		await expect(app.fileName).toHaveValue('Meeting notes');
+		expect(await app.storedPaths()).toEqual([
+			'Groceries.md',
+			'Meeting archive.md',
+			'Meeting notes.md',
+		]);
+	});
+
+	test('quick open opens again right after opening a file', async ({
+		app,
+		page,
+	}) => {
+		await writeNote(app, 'Alpha', 'a');
+		await writeNote(app, 'Beta', 'b');
+		const palette = page.getByRole('dialog', { name: 'Search and commands' });
+		for (const name of ['Alpha', 'Beta', 'Alpha']) {
+			await page.keyboard.press('ControlOrMeta+o');
+			await expect(palette).toBeVisible();
+			await page.keyboard.type(name.toLowerCase());
+			await expect(
+				palette.getByRole('option', { name: new RegExp(name) }),
+			).toBeVisible();
+			await page.keyboard.press('Enter');
+			await expect(app.fileName).toHaveValue(name);
+		}
+		// Letters typed right after the shortcut never reach the notes.
+		expect(await app.doc()).toBe('a');
+		expect(await app.storedBody('Alpha.md')).toBe(noteFileBody('a'));
+		expect(await app.storedBody('Beta.md')).toBe(noteFileBody('b'));
+	});
+
+	test('keys typed right after Cmd-O go to quick open, not the note', async ({
+		app,
+		page,
+	}) => {
+		await writeNote(app, 'Quiet', 'unchanged');
+		const palette = page.getByRole('dialog', { name: 'Search and commands' });
+		for (let round = 0; round < 3; round += 1) {
+			await app.editor().focus();
+			// No waiting between the shortcut and the typing.
+			await page.keyboard.press('ControlOrMeta+o');
+			await page.keyboard.type('quiet');
+			await expect(palette.getByRole('combobox')).toHaveValue('quiet');
+			await page.keyboard.press('Escape');
+			await expect(palette).toBeHidden();
+			// Escape gives the caret back to the note.
+			await expect(app.editor()).toBeFocused();
+		}
+		expect(await app.doc()).toBe('unchanged');
+		expect(await app.storedBody('Quiet.md')).toBe(noteFileBody('unchanged'));
+	});
+
+	test('a shortcut pressed twice quickly runs twice', async ({ app, page }) => {
+		await writeNote(app, 'One', '1');
+		await writeNote(app, 'Two', '2');
+		await writeNote(app, 'Three', '3');
+		await expect(page.getByRole('tab')).toHaveCount(3);
+		await page.keyboard.press('ControlOrMeta+w');
+		await page.keyboard.press('ControlOrMeta+w');
+		await expect(page.getByRole('tab')).toHaveText(['One']);
+		await expect(app.fileName).toHaveValue('One');
+	});
+
+	test('content search finds text inside notes', async ({ app, page }) => {
+		await writeNote(app, 'Recipe', 'Add the saffron last');
+		await writeNote(app, 'Other', 'nothing here');
+		await page.keyboard.press('ControlOrMeta+Shift+KeyF');
+		const palette = page.getByRole('dialog', { name: 'Search and commands' });
+		await expect(palette).toBeVisible();
+		await page.keyboard.type('saffron');
+		const result = palette.getByRole('option', { name: /Recipe/ });
+		await expect(result).toBeVisible();
+		await result.click();
+		await expect(app.fileName).toHaveValue('Recipe');
+	});
+});
+
+test.describe('wikilinks', () => {
+	test('[[ completion inserts a link that opens the note', async ({
+		app,
+		page,
+	}) => {
+		await writeNote(app, 'Target page', 'destination');
+		await app.newNote('Source');
+		await page.keyboard.type('See [[Targ');
+		const option = page.getByRole('option', { name: /Target page/ });
+		await expect(option).toBeVisible();
+		// CodeMirror ignores Enter for 75 ms after suggestions open, so a key
+		// pressed too early never picks one; a person is never that fast.
+		await page.waitForTimeout(150);
+		await page.keyboard.press('Enter');
+		expect(await app.doc()).toBe('See [[Target page]]');
+		await page.keyboard.type(' done');
+		expect(await app.doc()).toBe('See [[Target page]] done');
+		await expect
+			.poll(() => app.storedBody('Source.md'))
+			.toBe(noteFileBody('See [[Target page]] done'));
+		// Move the caret away so the link renders, then follow it.
+		await page.keyboard.press('ControlOrMeta+Home');
+		await page.keyboard.press('Enter');
+		await app.editor().getByText('Target page', { exact: true }).click();
+		await expect(app.fileName).toHaveValue('Target page');
+		expect(await app.doc()).toBe('destination');
+	});
+
+	test('Cmd-click opens a wikilink in a new tab', async ({ app, page }) => {
+		await writeNote(app, 'Linked', 'linked text');
+		await writeNote(app, 'Hub', 'Go to [[Linked]] now');
+		await page.keyboard.press('ControlOrMeta+Home');
+		await page.keyboard.press('Enter');
+		await tab(app, 'Linked').click();
+		await page.getByRole('button', { name: 'Close Linked' }).click();
+		await expect(page.getByRole('tab')).toHaveText(['Hub']);
+		await app
+			.editor()
+			.getByText('Linked', { exact: true })
+			.click({ modifiers: ['ControlOrMeta'] });
+		await expect(page.getByRole('tab')).toHaveText(['Hub', 'Linked']);
+		await expect(tab(app, 'Linked')).toHaveAttribute('title', 'Linked');
+	});
+
+	test('a link to a missing note says so and changes nothing', async ({
+		app,
+		page,
+	}) => {
+		await writeNote(app, 'Start', 'Make [[Brand new]] here');
+		await page.keyboard.press('ControlOrMeta+Home');
+		await page.keyboard.press('Enter');
+		await app.editor().getByText('Brand new', { exact: true }).click();
+		await expect(
+			page.getByText('“Brand new” isn’t in this workspace yet.'),
+		).toBeVisible();
+		await expect(app.fileName).toHaveValue('Start');
+		expect(await app.storedPaths()).toEqual(['Start.md']);
+	});
+});
+
+test.describe('coming back', () => {
+	test('reloading a module page stays on it', async ({ app, page }) => {
+		await expect(app.tree).toHaveCount(0);
+		const main = page.getByRole('main');
+		await page.goto('/tasks?view=all');
+		await expect(main.getByRole('heading', { name: 'Tasks' })).toBeVisible();
+		await page.goto('/calendar');
+		await expect(main.getByRole('heading', { name: 'Calendar' })).toBeVisible();
+		await page.goto('/projects');
+		await expect(main.getByText('Select a project')).toBeVisible();
+		await expect(page).toHaveURL(/\/projects$/);
+	});
+
+	test('reopening the app shows the last page and its document', async ({
+		app,
+		page,
+	}) => {
+		await writeNote(app, 'Last', 'last text');
+		await page.goto('/');
+		await expect(page).toHaveURL(/\/files\?selected=/);
+		await expect(app.fileName).toHaveValue('Last');
+		expect(await app.doc()).toBe('last text');
+	});
+
+	test('the Files page shows the highlighted tab’s document', async ({
+		app,
+		page,
+	}) => {
+		await writeNote(app, 'Shown', 'shown text');
+		await page
+			.getByRole('navigation', { name: 'Sections' })
+			.getByRole('link', { name: 'Home' })
+			.click();
+		await expect(app.fileName).toBeHidden();
+		await app.openFiles();
+		await expect(page.getByRole('tab', { selected: true })).toHaveText('Shown');
+		await expect(app.fileName).toHaveValue('Shown');
+		expect(await app.doc()).toBe('shown text');
+	});
+});
diff --git a/apps/app/tests/e2e/projects-calendar.e2e.ts b/apps/app/tests/e2e/projects-calendar.e2e.ts
new file mode 100644
index 0000000..b64cb2d
--- /dev/null
+++ b/apps/app/tests/e2e/projects-calendar.e2e.ts
@@ -0,0 +1,89 @@
+import { expect, test } from './fixtures';
+
+function today() {
+	const now = new Date();
+	const month = String(now.getMonth() + 1).padStart(2, '0');
+	const day = String(now.getDate()).padStart(2, '0');
+	return `${now.getFullYear()}-${month}-${day}`;
+}
+
+test.describe('projects', () => {
+	test('a new project keeps its title and overview typed across saves', async ({
+		app,
+		page,
+	}) => {
+		await page.goto('/projects');
+		await page.getByRole('button', { name: 'New project' }).first().click();
+		const title = page.getByRole('textbox', { name: 'Project title' });
+		await expect(title).toHaveValue('New project');
+		await title.click();
+		await page.keyboard.press('ControlOrMeta+a');
+		await page.keyboard.type('Garden ');
+		await page.waitForTimeout(400);
+		await page.keyboard.type('plan');
+		await app.editor('Project overview').click();
+		let typed = '';
+		for (const chunk of ['Beds and ', 'paths  ', 'first']) {
+			await page.keyboard.type(chunk, { delay: 20 });
+			typed += chunk;
+			await page.waitForTimeout(350);
+		}
+		await page.keyboard.press('Enter');
+		await page.keyboard.type('- dig');
+		typed += '\n- dig';
+		expect(await app.doc('Project overview')).toBe(typed);
+		await expect(title).toHaveValue('Garden plan');
+		const path = 'projects/new-project--';
+		await expect
+			.poll(async () => {
+				const file = (await app.storedPaths()).find(
+					(entry) => entry.startsWith(path) && entry.endsWith('project.md'),
+				);
+				const text = file ? await app.stored(file) : null;
+				return text?.slice(text.indexOf('\n# '));
+			})
+			.toBe(`\n# Garden plan\n\n${typed}\n`);
+		await page.getByLabel('Project status').click();
+		await page.getByRole('option', { name: 'Active' }).click();
+		await expect(page.getByLabel('Project status')).toHaveText('Active');
+		expect(await app.doc('Project overview')).toBe(typed);
+		expect(await app.messages()).toEqual([]);
+	});
+});
+
+test.describe('calendar', () => {
+	test('a task due today shows on the calendar and on Home, and opens', async ({
+		app,
+		page,
+	}) => {
+		await page.goto('/tasks?view=all');
+		await page.getByRole('button', { name: 'New task' }).click();
+		const title = page.getByRole('textbox', { name: 'Task title' });
+		await title.click();
+		await page.keyboard.press('ControlOrMeta+a');
+		await page.keyboard.type('Dentist');
+		await page.locator('input[type="date"]').fill(today());
+		await expect
+			.poll(async () => {
+				const file = (await app.storedPaths()).find((entry) =>
+					entry.startsWith('tasks/'),
+				);
+				return file ? await app.stored(file) : null;
+			})
+			.toMatch(new RegExp(`^due: '?${today()}'?$`, 'm'));
+		await page
+			.getByRole('navigation', { name: 'Sections' })
+			.getByRole('link', { name: 'Calendar' })
+			.click();
+		const entry = page.getByRole('main').getByText('Dentist');
+		await expect(entry).toBeVisible();
+		await page
+			.getByRole('navigation', { name: 'Sections' })
+			.getByRole('link', { name: 'Home' })
+			.click();
+		const upcoming = page.getByRole('region', { name: 'Next 7 days' });
+		await expect(upcoming.getByRole('link', { name: /Dentist/ })).toBeVisible();
+		await upcoming.getByRole('link', { name: /Dentist/ }).click();
+		await expect(title).toHaveValue('Dentist');
+	});
+});
diff --git a/apps/app/tests/e2e/rendering.e2e.ts b/apps/app/tests/e2e/rendering.e2e.ts
new file mode 100644
index 0000000..667f162
--- /dev/null
+++ b/apps/app/tests/e2e/rendering.e2e.ts
@@ -0,0 +1,124 @@
+import type { Locator, Page } from '@playwright/test';
+import { expect, test, type App } from './fixtures';
+
+const DOC = [
+	'> [!note] Remember',
+	'> Callout body',
+	'',
+	'- [ ] open',
+	'- [x] done',
+	'',
+	'```ts',
+	'const a = 1;',
+	'let text = "hi"; // note',
+	'```',
+	'',
+	'Last line',
+].join('\n');
+
+async function openRendered(app: App) {
+	await app.openFiles();
+	await app.writeOutside('Rendered.md', DOC);
+	await app.treeItem('Rendered').click();
+	await expect(app.editor('File text')).toBeVisible();
+	// Keep the caret on the last line so every block above renders.
+	await app.caretAfter('Last line', 'File text');
+}
+
+/** WCAG contrast of two CSS colors, resolved by the browser. */
+async function contrast(page: Page, foreground: Locator, background: Locator) {
+	const colors = [
+		await foreground.evaluate((element) => getComputedStyle(element).color),
+		await background.evaluate(
+			(element) => getComputedStyle(element).backgroundColor,
+		),
+	];
+	return page.evaluate((colors) => {
+		const canvas = document.createElement('canvas');
+		canvas.width = canvas.height = 1;
+		const context = canvas.getContext('2d', { willReadFrequently: true })!;
+		const luminance = (color: string) => {
+			context.clearRect(0, 0, 1, 1);
+			context.fillStyle = color;
+			context.fillRect(0, 0, 1, 1);
+			const [r, g, b] = [...context.getImageData(0, 0, 1, 1).data].map(
+				(value) => {
+					const channel = value / 255;
+					return channel <= 0.03928
+						? channel / 12.92
+						: ((channel + 0.055) / 1.055) ** 2.4;
+				},
+			);
+			return 0.2126 * r! + 0.7152 * g! + 0.0722 * b!;
+		};
+		const [first, second] = colors.map(luminance) as [number, number];
+		return (Math.max(first, second) + 0.05) / (Math.min(first, second) + 0.05);
+	}, colors);
+}
+
+for (const colorScheme of ['light', 'dark'] as const) {
+	test.describe(`rendered Markdown, ${colorScheme}`, () => {
+		test.use({ colorScheme });
+
+		test('code keeps readable colors', async ({ app, page }) => {
+			await openRendered(app);
+			const editor = app.editor('File text');
+			const block = editor.locator('.cm-md-codeblock').nth(1);
+			for (const token of ['.tok-keyword', '.tok-definition', '.tok-string'])
+				expect(
+					await contrast(
+						page,
+						editor.locator(`.cm-md-codeblock ${token}`).first(),
+						block,
+					),
+					`${token} in ${colorScheme}`,
+				).toBeGreaterThanOrEqual(4.5);
+		});
+
+		test('a checked checkbox shows a check mark', async ({ app, page }) => {
+			await openRendered(app);
+			const box = app
+				.editor('File text')
+				.locator('.cm-md-checkbox[aria-checked="true"]');
+			await expect(box).toBeVisible();
+			const mark = await box.evaluate((element) => {
+				const style = getComputedStyle(element, '::after');
+				return {
+					mask: style.maskImage || style.webkitMaskImage,
+					color: style.backgroundColor,
+					fill: getComputedStyle(element).backgroundColor,
+				};
+			});
+			expect(mark.mask).toContain('url(');
+			const ratio = await page.evaluate(
+				({ color, fill }) => {
+					const canvas = document.createElement('canvas');
+					const context = canvas.getContext('2d')!;
+					const read = (value: string) => {
+						context.fillStyle = value;
+						context.fillRect(0, 0, 1, 1);
+						return [...context.getImageData(0, 0, 1, 1).data];
+					};
+					const [a, b] = [read(color), read(fill)];
+					return Math.abs(a[0]! - b[0]!) + Math.abs(a[1]! - b[1]!);
+				},
+				{ color: mark.color, fill: mark.fill },
+			);
+			expect(ratio).toBeGreaterThan(200);
+		});
+
+		test('a callout hides its markers and names its type', async ({ app }) => {
+			await openRendered(app);
+			const lines = app.editor('File text').locator('.cm-md-callout');
+			// What people see, with text-transform applied.
+			const shown = (index: number) =>
+				lines.nth(index).evaluate((element: HTMLElement) => element.innerText);
+			await expect.poll(() => shown(0)).toBe('Note Remember');
+			await expect.poll(() => shown(1)).toBe('Callout body');
+			// With the caret inside, the source shows again.
+			await app.caretAfter('Callout', 'File text');
+			await expect.poll(() => shown(0)).toBe('> [!note] Remember');
+			await expect.poll(() => shown(1)).toBe('> Callout body');
+		});
+	});
+}
diff --git a/apps/app/tests/e2e/tasks.e2e.ts b/apps/app/tests/e2e/tasks.e2e.ts
new file mode 100644
index 0000000..4242017
--- /dev/null
+++ b/apps/app/tests/e2e/tasks.e2e.ts
@@ -0,0 +1,176 @@
+import { expect, noteFileBody, test, type App } from './fixtures';
+
+/** Today in the browser's time zone, as a task's `due` value. */
+function today() {
+	const now = new Date();
+	const month = String(now.getMonth() + 1).padStart(2, '0');
+	const day = String(now.getDate()).padStart(2, '0');
+	return `${now.getFullYear()}-${month}-${day}`;
+}
+
+async function taskPath(app: App, title: string): Promise<string> {
+	const slug = title.toLowerCase().replaceAll(' ', '-');
+	let found: string | undefined;
+	await expect
+		.poll(async () => {
+			found = (await app.storedPaths()).find((path) =>
+				path.startsWith(`tasks/${slug}--`),
+			);
+			return found;
+		})
+		.toBeTruthy();
+	return found!;
+}
+
+/** The value of `key` in a stored file's header, or null. */
+function header(text: string | null, key: string): string | null {
+	return text?.match(new RegExp(`^${key}: (.*)$`, 'm'))?.[1] ?? null;
+}
+
+async function openTasks(app: App, view = 'all') {
+	await app.page.goto(`/tasks?view=${view}`);
+	await expect(app.page.getByRole('heading', { name: 'Tasks' })).toBeVisible();
+}
+
+async function newTask(app: App, title: string) {
+	await openTasks(app);
+	await app.page.getByRole('button', { name: 'New task' }).click();
+	const name = app.page.getByRole('textbox', { name: 'Task title' });
+	await expect(name).toHaveValue('New task');
+	await name.click();
+	await app.page.keyboard.press('ControlOrMeta+a');
+	await app.page.keyboard.type(title);
+	// The file keeps the name it was created with; the title is inside it.
+	return taskPath(app, 'New task');
+}
+
+test.describe('Home', () => {
+	test('a task added for today shows under Due today and opens', async ({
+		app,
+		page,
+	}) => {
+		const input = page.getByRole('textbox', { name: 'Task' });
+		await input.click();
+		await page.keyboard.type('Buy milk');
+		await page.keyboard.press('Enter');
+		const today_ = page.getByRole('region', { name: 'Due today' });
+		await expect(today_.getByRole('link', { name: 'Buy milk' })).toBeVisible();
+		const path = await taskPath(app, 'Buy milk');
+		expect(header(await app.stored(path), 'due')).toBe(today());
+		await today_.getByRole('link', { name: 'Buy milk' }).click();
+		await expect(page.getByRole('textbox', { name: 'Task title' })).toHaveValue(
+			'Buy milk',
+		);
+		// Completing it from Home removes it from the list.
+		await page
+			.getByRole('navigation', { name: 'Sections' })
+			.getByRole('link', { name: 'Home' })
+			.click();
+		await today_.getByRole('button', { name: 'Complete Buy milk' }).click();
+		await expect(today_.getByText('Nothing due today.')).toBeVisible();
+		await expect
+			.poll(async () => header(await app.stored(path), 'status'))
+			.toBe('done');
+	});
+
+	test('recent notes open their note', async ({ app, page }) => {
+		await app.newNote('Diary');
+		await page.keyboard.type('dear diary');
+		await expect
+			.poll(() => app.storedBody('Diary.md'))
+			.toBe(noteFileBody('dear diary'));
+		await page
+			.getByRole('navigation', { name: 'Sections' })
+			.getByRole('link', { name: 'Home' })
+			.click();
+		const recent = page.getByRole('region', { name: 'Recent' });
+		await recent.getByRole('link', { name: 'Diary' }).click();
+		await expect(app.fileName).toHaveValue('Diary');
+		expect(await app.doc()).toBe('dear diary');
+	});
+});
+
+test.describe('tasks', () => {
+	test('typing a task’s title and body across saves loses nothing', async ({
+		app,
+		page,
+	}) => {
+		const path = await newTask(app, 'Write report');
+		const body = app.editor('Task body');
+		await body.click();
+		let typed = '';
+		for (const chunk of ['First line ', 'with spaces  ', 'and more ']) {
+			await page.keyboard.type(chunk, { delay: 20 });
+			typed += chunk;
+			await page.waitForTimeout(350);
+		}
+		await page.keyboard.press('Enter');
+		await page.keyboard.type('- item one');
+		typed += '\n- item one';
+		expect(await app.doc('Task body')).toBe(typed);
+		await expect
+			.poll(async () => {
+				const text = await app.stored(path);
+				return text?.slice(text.indexOf('# Write report'));
+			})
+			.toBe(`# Write report\n\n${typed}\n`);
+		expect(await app.doc('Task body')).toBe(typed);
+		await expect(page.getByRole('textbox', { name: 'Task title' })).toHaveValue(
+			'Write report',
+		);
+		expect(await app.messages()).toEqual([]);
+	});
+
+	test('changing properties while typing keeps both', async ({ app, page }) => {
+		const path = await newTask(app, 'Plan trip');
+		const body = app.editor('Task body');
+		await body.click();
+		await page.keyboard.type('pack bags ');
+		// A property change saves at once, in the middle of typing.
+		await page.getByLabel('Status', { exact: true }).click();
+		await page.getByRole('option', { name: /in progress/i }).click();
+		await body.click();
+		await page.keyboard.press('ControlOrMeta+End');
+		await page.keyboard.type('and passport');
+		await page.getByLabel('Priority', { exact: true }).click();
+		await page.getByRole('option', { name: /high/i }).click();
+		await expect
+			.poll(async () => {
+				const text = await app.stored(path);
+				return [
+					header(text, 'status'),
+					header(text, 'priority'),
+					text?.slice(text.indexOf('# Plan trip')),
+				];
+			})
+			.toEqual([
+				'in-progress',
+				'high',
+				'# Plan trip\n\npack bags and passport\n',
+			]);
+		expect(await app.doc('Task body')).toBe('pack bags and passport');
+	});
+
+	test('an outside edit to the open task merges with typing', async ({
+		app,
+		page,
+	}) => {
+		const path = await newTask(app, 'Shared task');
+		await app.editor('Task body').click();
+		await page.keyboard.type('local text');
+		await expect
+			.poll(async () => (await app.stored(path))?.endsWith('local text\n'))
+			.toBe(true);
+		const file = (await app.stored(path))!;
+		await app.writeOutside(path, `${file}\nfrom outside\n`);
+		await expect
+			.poll(() => app.doc('Task body'))
+			.toBe('local text\n\nfrom outside');
+		await app.caretToEnd('Task body');
+		await page.keyboard.type('!');
+		await expect
+			.poll(async () => (await app.stored(path))?.endsWith('from outside!\n'))
+			.toBe(true);
+		expect(await app.stored(path)).toContain('local text\n\nfrom outside!');
+	});
+});
diff --git a/bun.lock b/bun.lock
index d236d4d..6386078 100644
--- a/bun.lock
+++ b/bun.lock
@@ -39,6 +39,7 @@
       "devDependencies": {
         "@fontsource-variable/public-sans": "^5.3.0",
         "@internationalized/date": "^3.12.0",
+        "@playwright/test": "1.62.1",
         "@sveltejs/adapter-static": "latest",
         "@sveltejs/kit": "latest",
         "@sveltejs/vite-plugin-svelte": "latest",
@@ -592,10 +593,6 @@
 
     "@graphql-typed-document-node/core": ["@graphql-typed-document-node/core@3.2.0", "", { "peerDependencies": { "graphql": "^0.8.0 || ^0.9.0 || ^0.10.0 || ^0.11.0 || ^0.12.0 || ^0.13.0 || ^14.0.0 || ^15.0.0 || ^16.0.0 || ^17.0.0" } }, "sha512-mB9oAsNCm9aM3/SOv4YtBMqZbYj10R7dkq8byBqxGY/ncFwhf2oQzMV+LCRlWoDSEBJ3COiR1yeDvMtsoOsuFQ=="],
 
-    "@hapi/hoek": ["@hapi/hoek@9.3.0", "", {}, "sha512-/c6rf4UJlmHlC9b5BaNvzAcFv7HZ2QHaV0D4/HNlBdvFnvQq8RI4kYdhyPCl7Xj+oWvTWQ8ujhqS53LIgAe6KQ=="],
-
-    "@hapi/topo": ["@hapi/topo@5.1.0", "", { "dependencies": { "@hapi/hoek": "^9.0.0" } }, "sha512-foQZKJig7Ob0BMAYBfcJk8d77QtOe7Wo4ox7ff1lQYoNNAb6jwcY1ncdoy2e9wQZzvNy7ODZCYJkK8kzmcAnAg=="],
-
     "@happy-dom/global-registrator": ["@happy-dom/global-registrator@20.12.2", "", { "dependencies": { "@types/node": ">=20.0.0", "happy-dom": "^20.12.2" } }, "sha512-0aafW5l/+At7oo/lYjsokATwHKmv9F6iqOTjPDBVlmD4a6pmGINMdnt0faZuEcnvBVwBji0BoW4tdHQZ0qt9Kg=="],
 
     "@hexagon/base64": ["@hexagon/base64@1.1.28", "", {}, "sha512-lhqDEAvWixy3bZ+UOYbPwUbBkwBq5C1LAJ/xPC8Oi+lL54oyakv/npbA0aU2hgCsx/1NUd4IBvV03+aUBWxerw=="],
@@ -788,6 +785,8 @@
 
     "@peculiar/x509": ["@peculiar/x509@1.14.3", "", { "dependencies": { "@peculiar/asn1-cms": "^2.6.0", "@peculiar/asn1-csr": "^2.6.0", "@peculiar/asn1-ecc": "^2.6.0", "@peculiar/asn1-pkcs9": "^2.6.0", "@peculiar/asn1-rsa": "^2.6.0", "@peculiar/asn1-schema": "^2.6.0", "@peculiar/asn1-x509": "^2.6.0", "pvtsutils": "^1.3.6", "reflect-metadata": "^0.2.2", "tslib": "^2.8.1", "tsyringe": "^4.10.0" } }, "sha512-C2Xj8FZ0uHWeCXXqX5B4/gVFQmtSkiuOolzAgutjTfseNOHT3pUjljDZsTSxXFGgio54bCzVFqmEOUrIVk8RDA=="],
 
+    "@playwright/test": ["@playwright/test@1.62.1", "", { "dependencies": { "playwright": "1.62.1" }, "bin": { "playwright": "cli.js" } }, "sha512-DTcUc8qii+cpHvtOwggMtBRMjKZHXYWdw8syRYu2vtzuq4Wxphqq4NfCs5Zt44L6mA8rfDfj+PHnxFc/FeK6mQ=="],
+
     "@polka/url": ["@polka/url@1.0.0-next.29", "", {}, "sha512-wwQAWhWSuHaag8c4q/KN/vCoeOJYshAIvMQwD4GpSb3OiZklFfvAgmj0VCBBImRpuF/aFgIRzllXlVX93Jevww=="],
 
     "@poppinss/macroable": ["@poppinss/macroable@1.1.2", "", {}, "sha512-FAVBRzzWhYP5mA3lCwLH1A0fKBqq5anyjGet90Z81aRK5c/+LTGUE1zJhZrErjaenBSOOI9BVUs3WVmotneFQA=="],
@@ -844,12 +843,6 @@
 
     "@rolldown/pluginutils": ["@rolldown/pluginutils@1.0.1", "", {}, "sha512-2j9bGt5Jh8hj+vPtgzPtl72j0yRxHAyumoo6TNfAjsLB04UtpSvPbPcDcBMxz7n+9CYB0c1GxQFxYRg2jimqGw=="],
 
-    "@sideway/address": ["@sideway/address@4.1.5", "", { "dependencies": { "@hapi/hoek": "^9.0.0" } }, "sha512-IqO/DUQHUkPeixNQ8n0JA6102hT9CmaljNTPmQ1u8MEhBo/R4Q8eKLN/vGZxuebwOroDB4cbpjheD4+/sKFK4Q=="],
-
-    "@sideway/formula": ["@sideway/formula@3.0.1", "", {}, "sha512-/poHZJJVjx3L+zVD6g9KgHfYnb443oi7wLu/XKojDviHy6HOEOA6z1Trk5aR1dGcmPenJEgb2sK2I80LeS3MIg=="],
-
-    "@sideway/pinpoint": ["@sideway/pinpoint@2.0.0", "", {}, "sha512-RNiOoTPkptFtSVzQevY/yWtZwf/RxyVnPy/OcA9HBM3MlGDnBEYL5B41H0MTn0Uec8Hi+2qUtTfG2WWZBmMejQ=="],
-
     "@sigstore/bundle": ["@sigstore/bundle@4.0.0", "", { "dependencies": { "@sigstore/protobuf-specs": "^0.5.0" } }, "sha512-NwCl5Y0V6Di0NexvkTqdoVfmjTaQwoLM236r89KEojGmq/jMls8S+zb7yOwAPdXvbwfKDlP+lmXgAL4vKSQT+A=="],
 
     "@sigstore/core": ["@sigstore/core@3.2.1", "", {}, "sha512-qRsxPnCrbC/puegGxKuynfnxgLiHqWStrSjxkoB4YKqq3Z3s4cyZyj42ZdWFAEblNP65C+rBH8EuREHIXoi83g=="],
@@ -1214,8 +1207,6 @@
 
     "jiti": ["jiti@2.7.0", "", { "bin": { "jiti": "lib/jiti-cli.mjs" } }, "sha512-AC/7JofJvZGrrneWNaEnJeOLUx+JlGt7tNa0wZiRPT4MY1wmfKjt2+6O2p2uz2+skll8OZZmJMNqeke7kKbNgQ=="],
 
-    "joi": ["joi@17.13.6", "", { "dependencies": { "@hapi/hoek": "^9.3.0", "@hapi/topo": "^5.1.0", "@sideway/address": "^4.1.5", "@sideway/formula": "^3.0.1", "@sideway/pinpoint": "^2.0.0" } }, "sha512-ImNZaq/LSysofih+xIGYfR0WUXMA9GLUNB//YTCSrZptoRmVgaNAdJyi6K1kXi9pkLEoSkoI8I4UwtNiu/D7nw=="],
-
     "jose": ["jose@6.2.12", "", {}, "sha512-9NiFmJEex0sy2Dk58j2UGBSHgUs2ypF9eZSu4L6vjOX3Dp96Sw1F3uL+H+D1sx02jZZdzUT0HgvCy59CuvXcWw=="],
 
     "jsdom": ["jsdom@30.0.1", "", { "dependencies": { "@asamuzakjp/css-color": "^6.0.5", "@asamuzakjp/dom-selector": "^8.3.0", "@bramus/specificity": "^2.4.2", "@csstools/css-syntax-patches-for-csstree": "^1.1.7", "@exodus/bytes": "^1.15.1", "css-tree": "^3.2.1", "data-urls": "^7.0.0", "decimal.js": "^10.6.0", "html-encoding-sniffer": "^6.0.0", "is-potential-custom-element-name": "^1.0.1", "lru-cache": "^11.5.2", "parse5": "^8.0.1", "saxes": "^6.0.0", "symbol-tree": "^3.2.4", "tough-cookie": "^6.0.2", "undici": "^8.9.0", "w3c-xmlserializer": "^5.0.0", "webidl-conversions": "^8.0.1", "whatwg-mimetype": "^5.0.0", "whatwg-url": "^17.1.0", "xml-name-validator": "^5.0.0" }, "peerDependencies": { "canvas": "^3.2.3" }, "optionalPeers": ["canvas"] }, "sha512-52v7mUVUfNQVYYqE1lcdaymWL0njO7lTLUog6ZvW2U5KsbiLk/GnZlVJ+qx0xfNJZ6Gn+KSpPNE52vurbxZwrA=="],
@@ -1398,6 +1389,10 @@
 
     "picomatch": ["picomatch@4.0.7", "", {}, "sha512-qcJu88Q2IWqJsDD529JKMdwGm/dvInW4HvQnRwiH9JtihJvzGOscDtHE3x1pBKeUOTysQ8kVmLnJ2kJu7yhcGA=="],
 
+    "playwright": ["playwright@1.62.1", "", { "dependencies": { "playwright-core": "1.62.1" }, "optionalDependencies": { "fsevents": "2.3.2" }, "bin": { "playwright": "cli.js" } }, "sha512-0M+L3LAD8/nm554LOla9Ayx0j0tmFZ0FBcoQ7F1VuVHpM/XpiC8RcDzBQB8W5+hA8L22THxELzeF+2WcUzvcLg=="],
+
+    "playwright-core": ["playwright-core@1.62.1", "", { "bin": { "playwright-core": "cli.js" } }, "sha512-wPYSwEBJY9GHraISXqyqtx0na0LpO3XEX7jNDhntbex7tzUS7kLnZsOlFruFJB4Hi/rhDMjXGqHewDZ68nYZVw=="],
+
     "postcss": ["postcss@8.5.26", "", { "dependencies": { "nanoid": "^3.3.17", "picocolors": "^1.1.1", "source-map-js": "^1.2.1" } }, "sha512-u82N74LFzG8ca+dD8puPnplTXoGH4fTPpVGuIbt36G3qvNlkvfD0lEAZSxaly3KX8TS/L1A1gsCEmvKmBcVbkQ=="],
 
     "postcss-selector-parser": ["postcss-selector-parser@7.1.5", "", { "dependencies": { "cssesc": "^3.0.0", "util-deprecate": "^1.0.2" } }, "sha512-KvvtD7SrlBP7dlgkBghEE3r84CABm5SmV2aNcG4oCA+qDnJ/tvKonFVvwWAyyWUEwxuNawdfEAZKP9zM3oZ2Uw=="],
@@ -1724,10 +1719,10 @@
 
     "node-gyp/nopt": ["nopt@9.0.0", "", { "dependencies": { "abbrev": "^4.0.0" }, "bin": { "nopt": "bin/nopt.js" } }, "sha512-Zhq3a+yFKrYwSBluL4H9XP3m3y5uvQkB/09CwDruCiRmR/UJYnn9W4R48ry0uGC70aeTPKLynBtscP9efFFcPw=="],
 
-    "node-gyp/undici": ["undici@6.28.0", "", {}, "sha512-LIY910g9TI13YS95lrMFrs8Rm/u/irgHeTWoKCoteeJ04CUJ92eEfj0rVn+7VKMPBpUPiUoBKfhNyLI23EE/KA=="],
-
     "parse5/entities": ["entities@8.0.0", "", {}, "sha512-zwfzJecQ/Uej6tusMqwAqU/6KL2XaB2VZ2Jg54Je6ahNBGNH6Ek6g3jjNCF0fG9EWQKGZNddNjU5F1ZQn/sBnA=="],
 
+    "playwright/fsevents": ["fsevents@2.3.2", "", { "os": "darwin" }, "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA=="],
+
     "spdx-compare/spdx-expression-parse": ["spdx-expression-parse@3.0.1", "", { "dependencies": { "spdx-exceptions": "^2.1.0", "spdx-license-ids": "^3.0.0" } }, "sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q=="],
 
     "spdx-correct/spdx-expression-parse": ["spdx-expression-parse@3.0.1", "", { "dependencies": { "spdx-exceptions": "^2.1.0", "spdx-license-ids": "^3.0.0" } }, "sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q=="],
diff --git a/crates/local-core/src/engine/raw_markdown.rs b/crates/local-core/src/engine/raw_markdown.rs
index 0d1b063..b8cf7ca 100644
--- a/crates/local-core/src/engine/raw_markdown.rs
+++ b/crates/local-core/src/engine/raw_markdown.rs
@@ -309,6 +309,9 @@ impl WorkspaceEngine {
                 }
             }
         };
+        // The editor only replaces its text when another program's edit was
+        // folded in; a changed revision alone doesn't mean the body differs.
+        let external_merged = merged_body != input.local_body;
         let next_bytes = compose_raw_bytes(&merged_body, &layout);
         let next_relative = PathBuf::from(&relative);
         atomic_write_checked(
@@ -336,15 +339,23 @@ impl WorkspaceEngine {
             ParsedMarkdown::Managed(object) => Some(object),
             _ => None,
         };
-        Ok(RawSaveResult::Saved {
-            current: RawMarkdownRead {
-                relative_path: relative,
-                body: merged_body,
-                revision: markdown::revision(&next_bytes),
-                uses_crlf,
-                has_bom,
-            },
-            managed_object,
+        let current = RawMarkdownRead {
+            relative_path: relative,
+            body: merged_body,
+            revision: markdown::revision(&next_bytes),
+            uses_crlf,
+            has_bom,
+        };
+        Ok(if external_merged {
+            RawSaveResult::Merged {
+                current,
+                managed_object,
+            }
+        } else {
+            RawSaveResult::Saved {
+                current,
+                managed_object,
+            }
         })
     }
 
diff --git a/crates/local-core/tests/domain.rs b/crates/local-core/tests/domain.rs
index 52e7401..24c0532 100644
--- a/crates/local-core/tests/domain.rs
+++ b/crates/local-core/tests/domain.rs
@@ -1449,7 +1449,7 @@ fn raw_markdown_save_keeps_mixed_line_endings() {
             local_body: current.body.replace("# Mixed\n", "# Mixed today\n"),
         })
         .unwrap();
-    assert!(matches!(saved, RawSaveResult::Saved { .. }), "{saved:?}");
+    assert!(matches!(saved, RawSaveResult::Merged { .. }), "{saved:?}");
     assert_eq!(
         std::fs::read(&path).unwrap(),
         b"# Mixed today\r\n\r\nfrom windows\r\nfrom unix\nexternal\nlast\r\nadded\r\n"
@@ -2356,3 +2356,37 @@ fn moving_a_folder_allows_a_case_only_rename() {
         "path_exists"
     );
 }
+
+#[test]
+fn raw_saves_report_a_merge_only_when_another_edit_changed_the_text() {
+    let (workspace, _app_data, engine) = engine();
+    std::fs::write(workspace.path().join("doc.md"), "one\n\ntwo\n").unwrap();
+    engine.reconcile().unwrap();
+    let base = engine.read_raw_markdown("doc.md").unwrap();
+
+    // Another program edits the other end of the file before the save.
+    std::fs::write(workspace.path().join("doc.md"), "one\n\ntwo edited\n").unwrap();
+    let merged = engine
+        .save_raw_markdown(RawSaveInput {
+            relative_path: "doc.md".into(),
+            base_revision: base.revision.clone(),
+            base_body: base.body.clone(),
+            local_body: "one local\n\ntwo\n".into(),
+        })
+        .unwrap();
+    let RawSaveResult::Merged { current, .. } = merged else {
+        panic!("a merge with another edit must say so: {merged:?}")
+    };
+    assert_eq!(current.body, "one local\n\ntwo edited\n");
+
+    // A plain save of the current revision is not a merge.
+    let saved = engine
+        .save_raw_markdown(RawSaveInput {
+            relative_path: "doc.md".into(),
+            base_revision: current.revision.clone(),
+            base_body: current.body.clone(),
+            local_body: "one local \n\ntwo edited\n".into(),
+        })
+        .unwrap();
+    assert!(matches!(saved, RawSaveResult::Saved { .. }), "{saved:?}");
+}
diff --git a/crates/workspace-format/src/lib.rs b/crates/workspace-format/src/lib.rs
index 7f22a43..685c76f 100644
--- a/crates/workspace-format/src/lib.rs
+++ b/crates/workspace-format/src/lib.rs
@@ -593,9 +593,12 @@ pub fn serialize_object(object: &WorkspaceObject) -> Result<Vec<u8>, FormatError
     }
     let yaml = serde_yaml_ng::to_string(&ordered).map_err(|_| FormatError::ObjectSerialization)?;
     let mut result = format!("---\n{}---\n\n# {}\n", yaml, object.title.trim());
-    if !object.body.trim().is_empty() {
+    // Only line breaks at the end are normalized. Trailing spaces stay: two
+    // of them are a Markdown line break, and the editor may be mid-typing.
+    let body = object.body.trim_end_matches(['\n', '\r']);
+    if !body.trim().is_empty() {
         result.push('\n');
-        result.push_str(object.body.trim_end());
+        result.push_str(body);
         result.push('\n');
     }
     Ok(result.into_bytes())
@@ -727,6 +730,37 @@ mod tests {
         assert_eq!(first, second);
     }
 
+    #[test]
+    fn managed_bodies_keep_trailing_spaces_and_drop_trailing_line_breaks() {
+        let object = |body: &str| WorkspaceObject {
+            id: "note_01j00000000000000000000000".into(),
+            object_type: "note".into(),
+            title: "Example".into(),
+            body: body.into(),
+            relative_path: "notes/example.md".into(),
+            revision: String::new(),
+            created: Some("2026-08-27T12:00:00Z".into()),
+            updated: Some("2026-08-27T12:00:00Z".into()),
+            properties: BTreeMap::new(),
+        };
+        let body_after_round_trip = |body: &str| {
+            let bytes = serialize_object(&object(body)).unwrap();
+            let ParsedMarkdown::Managed(parsed) = parse_markdown("notes/example.md", &bytes) else {
+                panic!("managed object expected")
+            };
+            parsed.body
+        };
+        // A trailing space, or two for a Markdown line break, survives a save.
+        assert_eq!(body_after_round_trip("Typing "), "Typing ");
+        assert_eq!(body_after_round_trip("Line  \nnext"), "Line  \nnext");
+        // Line breaks at the end are normalized; the file ends with one.
+        assert_eq!(body_after_round_trip("Text\n\n"), "Text");
+        let bytes = serialize_object(&object("Text\n\n")).unwrap();
+        assert!(bytes.ends_with(b"Text\n"));
+        // A body of only whitespace is written as no body.
+        assert_eq!(body_after_round_trip("  \n"), "");
+    }
+
     #[test]
     fn malformed_frontmatter_is_not_managed() {
         let ParsedMarkdown::Malformed { error, .. } =
@@ -752,6 +786,15 @@ mod tests {
         object_id: Vec<ObjectIdFixture>,
         task_properties: Vec<TaskPropertiesFixture>,
         project_properties: Vec<TaskPropertiesFixture>,
+        object_body: Vec<ObjectBodyFixture>,
+    }
+
+    #[derive(Deserialize)]
+    struct ObjectBodyFixture {
+        name: String,
+        body: String,
+        expected_body: String,
+        file_ends_with: String,
     }
 
     #[derive(Deserialize)]
@@ -804,6 +847,35 @@ mod tests {
         );
     }
 
+    #[test]
+    fn object_bodies_round_trip_as_the_shared_fixtures_say() {
+        let fixtures: Fixtures = serde_json::from_str(include_str!(
+            "../../../docs/workspace-format/fixtures/conformance-v1.json"
+        ))
+        .unwrap();
+        for fixture in fixtures.object_body {
+            let object = WorkspaceObject {
+                id: "note_01j00000000000000000000000".into(),
+                object_type: "note".into(),
+                title: "Example".into(),
+                body: fixture.body,
+                relative_path: "notes/example.md".into(),
+                revision: String::new(),
+                created: Some("2026-08-27T12:00:00Z".into()),
+                updated: Some("2026-08-27T12:00:00Z".into()),
+                properties: BTreeMap::new(),
+            };
+            let bytes = serialize_object(&object).unwrap();
+            let text = String::from_utf8(bytes.clone()).unwrap();
+            assert!(text.ends_with(&fixture.file_ends_with), "{}", fixture.name);
+            let ParsedMarkdown::Managed(parsed) = parse_markdown(&object.relative_path, &bytes)
+            else {
+                panic!("{}: managed object expected", fixture.name)
+            };
+            assert_eq!(parsed.body, fixture.expected_body, "{}", fixture.name);
+        }
+    }
+
     #[test]
     fn manifest_parser_sorts_and_deduplicates_plugins() {
         let manifest = parse_workspace_manifest(
diff --git a/docs/workspace-format/fixtures/conformance-v1.json b/docs/workspace-format/fixtures/conformance-v1.json
index e7e0657..465405d 100644
--- a/docs/workspace-format/fixtures/conformance-v1.json
+++ b/docs/workspace-format/fixtures/conformance-v1.json
@@ -583,5 +583,37 @@
 				"updated": "2026-09-02T12:01:00Z"
 			}
 		}
+	],
+	"object_body": [
+		{
+			"name": "trailing space typed at the end stays",
+			"body": "Typing ",
+			"expected_body": "Typing ",
+			"file_ends_with": "Typing \n"
+		},
+		{
+			"name": "two trailing spaces keep a Markdown line break",
+			"body": "Line  \nnext",
+			"expected_body": "Line  \nnext",
+			"file_ends_with": "Line  \nnext\n"
+		},
+		{
+			"name": "trailing line breaks normalize to one final newline",
+			"body": "Text\n\n",
+			"expected_body": "Text",
+			"file_ends_with": "Text\n"
+		},
+		{
+			"name": "CRLF line breaks at the end normalize too",
+			"body": "Text\r\n",
+			"expected_body": "Text",
+			"file_ends_with": "Text\n"
+		},
+		{
+			"name": "a body of only whitespace is written as no body",
+			"body": "  \n",
+			"expected_body": "",
+			"file_ends_with": "# Example\n"
+		}
 	]
 }
diff --git a/packages/browser-workspace/src/worker.ts b/packages/browser-workspace/src/worker.ts
index 949ba2f..caeff09 100644
--- a/packages/browser-workspace/src/worker.ts
+++ b/packages/browser-workspace/src/worker.ts
@@ -1426,7 +1426,14 @@ export class BrowserWorkspaceServer {
 			);
 			body = merged;
 		}
-		return this.#writeRaw(path, stored, body, operation, 'saved');
+		// Report a merge only when another edit changed the text saved.
+		return this.#writeRaw(
+			path,
+			stored,
+			body,
+			operation,
+			body === localBody ? 'saved' : 'merged',
+		);
 	}
 
 	async #writeRaw(
@@ -1434,7 +1441,7 @@ export class BrowserWorkspaceServer {
 		stored: { bytes: Uint8Array; revision: string },
 		body: string,
 		operation: string,
-		status: 'saved' | null,
+		status: 'saved' | 'merged' | null,
 	) {
 		const next = this.#format.composeRawText(stored.bytes, body);
 		const written = await this.#requireCurrent(operation).storage.write({
diff --git a/packages/browser-workspace/src/worker.wasm.test.ts b/packages/browser-workspace/src/worker.wasm.test.ts
index 444c470..a31bfd1 100644
--- a/packages/browser-workspace/src/worker.wasm.test.ts
+++ b/packages/browser-workspace/src/worker.wasm.test.ts
@@ -189,7 +189,8 @@ describe.skipIf(format === null)('browser raw Markdown', () => {
 				localBody: '# Loose\n\nfirst, edited\nmiddle\nsecond\n',
 			},
 		})) as { status: string; current: RawMarkdownRead };
-		expect(saved.status).toBe('saved');
+		// The other tab's edit was folded in, so the save reports a merge.
+		expect(saved.status).toBe('merged');
 		expect(decoder.decode(files.files.get('Loose.md'))).toBe(
 			'# Loose\r\n\r\nfirst, edited\r\nmiddle\r\nsecond, changed\r\n',
 		);
diff --git a/packages/editor/src/factory.ts b/packages/editor/src/factory.ts
index ca90d62..d273e42 100644
--- a/packages/editor/src/factory.ts
+++ b/packages/editor/src/factory.ts
@@ -413,22 +413,22 @@ const editorTheme = EditorView.theme({
 	},
 	'.cm-md-code-fence': { color: 'var(--muted-foreground)' },
 	'.cm-md-codeblock .tok-keyword, .cm-md-codeblock .tok-operatorKeyword': {
-		color: 'var(--chart-4, #8250df)',
+		color: 'var(--syntax-keyword, #6f42c1)',
 	},
 	'.cm-md-codeblock .tok-string, .cm-md-codeblock .tok-string2': {
-		color: 'var(--chart-2, #0a7f4f)',
+		color: 'var(--syntax-string, #116329)',
 	},
 	'.cm-md-codeblock .tok-number, .cm-md-codeblock .tok-bool, .cm-md-codeblock .tok-atom':
-		{ color: 'var(--chart-1, #b35900)' },
+		{ color: 'var(--syntax-number, #953800)' },
 	'.cm-md-codeblock .tok-comment': {
 		color: 'var(--muted-foreground)',
 		fontStyle: 'italic',
 	},
 	'.cm-md-codeblock .tok-typeName, .cm-md-codeblock .tok-className': {
-		color: 'var(--chart-3, #0550ae)',
+		color: 'var(--syntax-type, #0550ae)',
 	},
 	'.cm-md-codeblock .tok-definition, .cm-md-codeblock .tok-propertyName': {
-		color: 'var(--chart-5, #953800)',
+		color: 'var(--syntax-definition, #0a3069)',
 	},
 	'.cm-md-math-source': { fontFamily: 'var(--font-mono, monospace)' },
 	'.cm-md-callout': {
@@ -438,12 +438,11 @@ const editorTheme = EditorView.theme({
 	},
 	'.cm-md-callout-title': { fontWeight: '600' },
 	'.cm-md-callout-type': { color: 'var(--muted-foreground)' },
-	'.cm-md-task-line .cm-md-checkbox': { verticalAlign: 'middle' },
-	'.cm-md-checkbox[data-checked="true"]': {
-		backgroundImage:
-			"url(\"data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16' fill='none' stroke='white' stroke-width='2.5' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpath d='M3.5 8.5l3 3 6-7'/%3E%3C/svg%3E\")",
-		backgroundSize: '100% 100%',
+	'.cm-md-callout-label': {
+		color: 'var(--muted-foreground)',
+		textTransform: 'capitalize',
 	},
+	'.cm-md-task-line .cm-md-checkbox': { verticalAlign: 'middle' },
 	'.cm-md-hr-line': {
 		backgroundImage: 'linear-gradient(var(--border), var(--border))',
 		backgroundSize: '100% 1px',
diff --git a/packages/editor/src/preview.test.ts b/packages/editor/src/preview.test.ts
index 88706b9..93ef36c 100644
--- a/packages/editor/src/preview.test.ts
+++ b/packages/editor/src/preview.test.ts
@@ -243,18 +243,38 @@ describe('blocks', () => {
 			expect(lineClasses(state, ranges, line)).toContain('cm-md-quote-line');
 	});
 
-	test('styles every line of a callout and hides the type marker', () => {
+	test('styles every line of a callout and hides its markers', () => {
 		const doc = '> [!note] Title\n> body\n\nafter\n';
 		const { state, ranges } = decorate(doc, doc.length);
 		expect(lineClasses(state, ranges, 1)).toContain('cm-md-callout');
 		expect(lineClasses(state, ranges, 2)).toContain('cm-md-callout');
+		const hidden = hiddenRanges(ranges).map((item) => [
+			item.from,
+			state.sliceDoc(item.from, item.to),
+		]);
+		// Both `>` markers, and the brackets around the type.
+		expect(hidden).toEqual([
+			[0, '> '],
+			[2, '[!'],
+			[8, ']'],
+			[16, '> '],
+		]);
+		// The type shows as a label.
 		expect(
-			hiddenRanges(ranges).some(
-				(item) => state.sliceDoc(item.from, item.to) === '[!note] ',
+			ranges.some(
+				(item) =>
+					item.spec.class === 'cm-md-callout-label' &&
+					state.sliceDoc(item.from, item.to) === 'note',
 			),
 		).toBe(true);
 	});
 
+	test('shows a callout’s source while the caret is in it', () => {
+		const doc = '> [!warning]- Careful\n> body\n\nafter\n';
+		const { ranges } = decorate(doc, doc.indexOf('body') + 2);
+		expect(hiddenRanges(ranges)).toHaveLength(0);
+	});
+
 	test('marks fenced code lines for styling', () => {
 		const doc = '```js\nconst a = 1;\n```\n\nafter\n';
 		const { state, ranges } = decorate(doc, doc.length);
diff --git a/packages/editor/src/preview.ts b/packages/editor/src/preview.ts
index ab926f8..f284ca0 100644
--- a/packages/editor/src/preview.ts
+++ b/packages/editor/src/preview.ts
@@ -364,13 +364,25 @@ function decorateBlockquote(cx: DecorationContext, node: SyntaxNode) {
 	eachLine(node.from, node.to, (from) => addLine(from, quoteClass));
 	if (!callout) return;
 	addLine(firstLine.from, 'cm-md-callout-title');
+	const marker = callout[2] ?? '';
 	const typeFrom = firstLine.from + (callout[1] ?? '').length;
-	const typeTo = typeFrom + (callout[2] ?? '').length;
-	if (revealed(firstLine.from, firstLine.to)) {
+	const typeTo = typeFrom + marker.length;
+	const lastLine = state.doc.lineAt(Math.max(node.from, node.to - 1));
+	// Like Obsidian, the source shows while the caret is anywhere in the
+	// callout; otherwise the `>` markers hide and `[!note]` reads "note".
+	if (revealed(firstLine.from, lastLine.to)) {
 		addMark(typeFrom, typeTo, 'cm-md-callout-type');
-	} else {
-		addReplace(typeFrom, typeTo + (callout[3] ?? '').length, {});
+		return;
 	}
+	eachLine(node.from, node.to, (from) => {
+		const quote = /^(\s*)>[ \t]?/.exec(state.doc.lineAt(from).text);
+		if (quote)
+			addReplace(from + (quote[1] ?? '').length, from + quote[0].length, {});
+	});
+	const close = marker.indexOf(']');
+	addReplace(typeFrom, typeFrom + 2, {});
+	addMark(typeFrom + 2, typeFrom + close, 'cm-md-callout-label');
+	addReplace(typeFrom + close, typeTo, {});
 }
 
 function linkParts(state: EditorState, node: SyntaxNode) {
diff --git a/packages/workspace-format-wasm/scripts/test-wasm-runtime.ts b/packages/workspace-format-wasm/scripts/test-wasm-runtime.ts
index 6e38889..fdb0d2c 100644
--- a/packages/workspace-format-wasm/scripts/test-wasm-runtime.ts
+++ b/packages/workspace-format-wasm/scripts/test-wasm-runtime.ts
@@ -14,6 +14,12 @@ type Fixtures = {
 		valid: boolean;
 		value: Record<string, unknown>;
 	}>;
+	object_body: Array<{
+		name: string;
+		body: string;
+		expected_body: string;
+		file_ends_with: string;
+	}>;
 };
 
 const wasmModule = new URL('../wasm/workspace_format_wasm.js', import.meta.url);
@@ -126,6 +132,26 @@ const parsed = format.parseMarkdown(object.relativePath, bytes);
 assert.equal(parsed.kind, 'managed');
 assert.deepEqual(format.serializeObject(parsed), bytes);
 
+// Browser saves go through the same serializer, so bodies must round-trip
+// exactly as the shared fixtures say.
+const decoder = new TextDecoder();
+for (const fixture of fixtures.object_body) {
+	const fixtureBytes = format.serializeObject({
+		...object,
+		title: 'Example',
+		properties: {},
+		body: fixture.body,
+	});
+	assert.ok(
+		decoder.decode(fixtureBytes).endsWith(fixture.file_ends_with),
+		fixture.name,
+	);
+	const fixtureParsed = format.parseMarkdown(object.relativePath, fixtureBytes);
+	assert.equal(fixtureParsed.kind, 'managed', fixture.name);
+	if (fixtureParsed.kind === 'managed')
+		assert.equal(fixtureParsed.body, fixture.expected_body, fixture.name);
+}
+
 const created = format.createNote({
 	title: 'Created in Rust',
 	body: 'The worker persists these canonical bytes.',