diff --git a/CLAUDE.md b/CLAUDE.md
index bbd8144..2c1f349 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -164,9 +164,9 @@ All examples use [Pico CSS](https://picocss.com/docs) exclusively:
 - Use semantic HTML — Pico auto-styles: `<article>` (cards), `<dialog>` (modals), `<details>` (accordions), `<table>`, `<nav>`, `<progress>`
 - Use Pico classes sparingly: `.container`, `.grid`, `.secondary`, `.contrast`, `.outline`
 - Use `aria-invalid="true"` for form validation errors, `<small>` for helper/error text
-- Use `<ins>` for success messages, `<del>` for error messages, using the standardized inline style `style="display:block;text-decoration:none"` when rendering them as block-level alerts
-- Use `<s>` for strikethrough text (e.g., completed todos), `<del>` for removed/error content
-- Use `<mark>` for highlighted/badge text
+- Use `<ins>` for success messages, `<del>` for primary error messages, using the standardized inline style `style="display:block;text-decoration:none"` when rendering them as block-level alerts
+- Use `<s>` for strikethrough text (e.g., completed todos), `<del>` for removed content and primary error alerts
+- Use `<mark>` for highlighted/badge text and for secondary inline error detail alongside a primary `FlashTag`/`<del>` alert. Wrap in `aria-live="assertive"` when the detail is the sole announcement. (Rule of thumb: `<del>` is the primary alert; `<mark>` is a secondary highlight on the same page.)
 - Use `<progress>` for progress bars
 - Use `<hgroup>` for title + subtitle groupings
 - Use `<fieldset role="group">` for inline input+button groups
diff --git a/go.mod b/go.mod
index 7a2a716..078a795 100644
--- a/go.mod
+++ b/go.mod
@@ -7,28 +7,17 @@ require (
 	github.com/chromedp/chromedp v0.14.2
 	github.com/go-playground/validator/v10 v10.30.1
 	github.com/gorilla/websocket v1.5.3
-	github.com/livetemplate/livetemplate v0.8.17
+	github.com/livetemplate/livetemplate v0.8.18
 	github.com/livetemplate/lvt v0.1.4-0.20260410132914-2f543135f074
 	github.com/livetemplate/lvt/components v0.1.2
 	modernc.org/sqlite v1.43.0
 )
 
 require (
-	github.com/atotto/clipboard v0.1.4 // indirect
-	github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
-	github.com/brianvoe/gofakeit/v7 v7.8.2 // indirect
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
-	github.com/charmbracelet/bubbles v0.21.0 // indirect
-	github.com/charmbracelet/bubbletea v1.3.10 // indirect
-	github.com/charmbracelet/colorprofile v0.2.3-0.20250311203215-f60798e515dc // indirect
-	github.com/charmbracelet/lipgloss v1.1.0 // indirect
-	github.com/charmbracelet/x/ansi v0.10.1 // indirect
-	github.com/charmbracelet/x/cellbuf v0.0.13-0.20250311204145-2c3ea96c31dd // indirect
-	github.com/charmbracelet/x/term v0.2.1 // indirect
 	github.com/chromedp/sysutil v1.1.0 // indirect
 	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
 	github.com/dustin/go-humanize v1.0.1 // indirect
-	github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f // indirect
 	github.com/gabriel-vasile/mimetype v1.4.12 // indirect
 	github.com/go-json-experiment/json v0.0.0-20260214004413-d219187c3433 // indirect
 	github.com/go-playground/locales v0.14.1 // indirect
@@ -39,35 +28,20 @@ require (
 	github.com/google/uuid v1.6.0 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
 	github.com/leodido/go-urn v1.4.0 // indirect
-	github.com/lucasb-eyer/go-colorful v1.2.0 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
-	github.com/mattn/go-localereader v0.0.1 // indirect
-	github.com/mattn/go-runewidth v0.0.16 // indirect
-	github.com/mfridman/interpolate v0.0.2 // indirect
 	github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421 // indirect
 	github.com/modern-go/reflect2 v1.0.2 // indirect
-	github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 // indirect
-	github.com/muesli/cancelreader v0.2.2 // indirect
-	github.com/muesli/termenv v0.16.0 // indirect
 	github.com/ncruces/go-strftime v1.0.0 // indirect
-	github.com/pressly/goose/v3 v3.26.0 // indirect
 	github.com/redis/go-redis/v9 v9.17.2 // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
-	github.com/rivo/uniseg v0.4.7 // indirect
-	github.com/sethvargo/go-retry v0.3.0 // indirect
 	github.com/tdewolff/minify/v2 v2.24.8 // indirect
 	github.com/tdewolff/parse/v2 v2.8.5 // indirect
-	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
-	go.uber.org/multierr v1.11.0 // indirect
 	golang.org/x/crypto v0.48.0 // indirect
 	golang.org/x/exp v0.0.0-20251219203646-944ab1f22d93 // indirect
-	golang.org/x/mod v0.33.0 // indirect
 	golang.org/x/net v0.50.0 // indirect
-	golang.org/x/sync v0.20.0 // indirect
 	golang.org/x/sys v0.41.0 // indirect
 	golang.org/x/text v0.35.0 // indirect
 	golang.org/x/time v0.14.0 // indirect
-	gopkg.in/yaml.v3 v3.0.1 // indirect
 	modernc.org/libc v1.67.4 // indirect
 	modernc.org/mathutil v1.7.1 // indirect
 	modernc.org/memory v1.11.0 // indirect
diff --git a/go.sum b/go.sum
index 46307e8..5d29d91 100644
--- a/go.sum
+++ b/go.sum
@@ -4,12 +4,6 @@ github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1 h1:UQHMgLO+TxOEl
 github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E=
 github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY=
 github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU=
-github.com/atotto/clipboard v0.1.4 h1:EH0zSVneZPSuFR11BlR9YppQTVDbh5+16AmcJi4g1z4=
-github.com/atotto/clipboard v0.1.4/go.mod h1:ZY9tmq7sm5xIbd9bOK4onWV4S6X0u6GY7Vn0Yu86PYI=
-github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k=
-github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8=
-github.com/brianvoe/gofakeit/v7 v7.8.2 h1:FWxoSP4Ss9LWSvTOrWZHz7sIHcpZwLVw2xa/DhJABB4=
-github.com/brianvoe/gofakeit/v7 v7.8.2/go.mod h1:QXuPeBw164PJCzCUZVmgpgHJ3Llj49jSLVkKPMtxtxA=
 github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs=
 github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c=
 github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA=
@@ -18,20 +12,6 @@ github.com/cenkalti/backoff/v4 v4.2.1 h1:y4OZtCnogmCPw98Zjyt5a6+QwPLGkiQsYW5oUqy
 github.com/cenkalti/backoff/v4 v4.2.1/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE=
 github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
 github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
-github.com/charmbracelet/bubbles v0.21.0 h1:9TdC97SdRVg/1aaXNVWfFH3nnLAwOXr8Fn6u6mfQdFs=
-github.com/charmbracelet/bubbles v0.21.0/go.mod h1:HF+v6QUR4HkEpz62dx7ym2xc71/KBHg+zKwJtMw+qtg=
-github.com/charmbracelet/bubbletea v1.3.10 h1:otUDHWMMzQSB0Pkc87rm691KZ3SWa4KUlvF9nRvCICw=
-github.com/charmbracelet/bubbletea v1.3.10/go.mod h1:ORQfo0fk8U+po9VaNvnV95UPWA1BitP1E0N6xJPlHr4=
-github.com/charmbracelet/colorprofile v0.2.3-0.20250311203215-f60798e515dc h1:4pZI35227imm7yK2bGPcfpFEmuY1gc2YSTShr4iJBfs=
-github.com/charmbracelet/colorprofile v0.2.3-0.20250311203215-f60798e515dc/go.mod h1:X4/0JoqgTIPSFcRA/P6INZzIuyqdFY5rm8tb41s9okk=
-github.com/charmbracelet/lipgloss v1.1.0 h1:vYXsiLHVkK7fp74RkV7b2kq9+zDLoEU4MZoFqR/noCY=
-github.com/charmbracelet/lipgloss v1.1.0/go.mod h1:/6Q8FR2o+kj8rz4Dq0zQc3vYf7X+B0binUUBwA0aL30=
-github.com/charmbracelet/x/ansi v0.10.1 h1:rL3Koar5XvX0pHGfovN03f5cxLbCF2YvLeyz7D2jVDQ=
-github.com/charmbracelet/x/ansi v0.10.1/go.mod h1:3RQDQ6lDnROptfpWuUVIUG64bD2g2BgntdxH0Ya5TeE=
-github.com/charmbracelet/x/cellbuf v0.0.13-0.20250311204145-2c3ea96c31dd h1:vy0GVL4jeHEwG5YOXDmi86oYw2yuYUGqz6a8sLwg0X8=
-github.com/charmbracelet/x/cellbuf v0.0.13-0.20250311204145-2c3ea96c31dd/go.mod h1:xe0nKWGd3eJgtqZRaN9RjMtK7xUYchjzPr7q6kcvCCs=
-github.com/charmbracelet/x/term v0.2.1 h1:AQeHeLZ1OqSXhrAWpYUtZyX1T3zVxfpZuEQMIQaGIAQ=
-github.com/charmbracelet/x/term v0.2.1/go.mod h1:oQ4enTYFV7QN4m0i9mzHrViD7TQKvNEEkHUMCmsxdUg=
 github.com/chromedp/cdproto v0.0.0-20250803210736-d308e07a266d h1:ZtA1sedVbEW7EW80Iz2GR3Ye6PwbJAJXjv7D74xG6HU=
 github.com/chromedp/cdproto v0.0.0-20250803210736-d308e07a266d/go.mod h1:NItd7aLkcfOA/dcMXvl8p1u+lQqioRMq/SqDp71Pb/k=
 github.com/chromedp/chromedp v0.14.2 h1:r3b/WtwM50RsBZHMUm9fsNhhzRStTHrKdr2zmwbZSzM=
@@ -65,8 +45,6 @@ github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkp
 github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
 github.com/ebitengine/purego v0.8.4 h1:CF7LEKg5FFOsASUj0+QwaXf8Ht6TlFxg09+S9wz0omw=
 github.com/ebitengine/purego v0.8.4/go.mod h1:iIjxzd6CiRiOG0UyXP+V1+jWqUXVjPKLAI0mRfJZTmQ=
-github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f h1:Y/CXytFA4m6baUTXGLOoWe4PQhGxaX0KpnayAqC48p4=
-github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f/go.mod h1:vw97MGsxSvLiUE2X8qFplwetxpGLQrlU1Q9AUEIzCaM=
 github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg=
 github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U=
 github.com/gabriel-vasile/mimetype v1.4.12 h1:e9hWvmLYvtp846tLHam2o++qitpguFiYCKbn0w9jyqw=
@@ -114,30 +92,20 @@ github.com/ledongthuc/pdf v0.0.0-20220302134840-0c2507a12d80 h1:6Yzfa6GP0rIo/kUL
 github.com/ledongthuc/pdf v0.0.0-20220302134840-0c2507a12d80/go.mod h1:imJHygn/1yfhB7XSJJKlFZKl/J+dCPAknuiaGOshXAs=
 github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ=
 github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI=
-github.com/livetemplate/livetemplate v0.8.17 h1:VE7KLD13hqUo0wVAej3DFcgQkS0FdVZcQHGzXF8h33k=
-github.com/livetemplate/livetemplate v0.8.17/go.mod h1:GMvZKyPUq8LSGfgD3pftKOHa6v+I+RDYyff2mNjeAYs=
-github.com/livetemplate/lvt v0.1.3 h1:owC7dKCnGoJBuUgeEFDmwqY7YcL3elgxnh7euNZBh5o=
-github.com/livetemplate/lvt v0.1.3/go.mod h1:17cFl500ntymD3gx8h+ZODnVnTictHgG8Wmz/By75sU=
+github.com/livetemplate/livetemplate v0.8.18 h1:UN74z9DinjV8I38NxUnLTfcAKMplI9XfuOAi4ApqbG0=
+github.com/livetemplate/livetemplate v0.8.18/go.mod h1:GMvZKyPUq8LSGfgD3pftKOHa6v+I+RDYyff2mNjeAYs=
 github.com/livetemplate/lvt v0.1.4-0.20260410132914-2f543135f074 h1:0YYh5Uc0bTTc6f8A66G91Fm213UwaexO81O7meTjscE=
 github.com/livetemplate/lvt v0.1.4-0.20260410132914-2f543135f074/go.mod h1:17cFl500ntymD3gx8h+ZODnVnTictHgG8Wmz/By75sU=
 github.com/livetemplate/lvt/components v0.1.2 h1:MM2M5IZnsUAu0py9ZbtcQCo0bvUrL4Z3Ly/yDkYNyag=
 github.com/livetemplate/lvt/components v0.1.2/go.mod h1:G9PElN3LRf8xoRtoxbOAcTkV/4FhrCE/Laczkz5bfL4=
-github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY=
-github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
 github.com/lufia/plan9stats v0.0.0-20211012122336-39d0f177ccd0 h1:6E+4a0GO5zZEnZ81pIr0yLvtUWk2if982qA3F3QD6H4=
 github.com/lufia/plan9stats v0.0.0-20211012122336-39d0f177ccd0/go.mod h1:zJYVVT2jmtg6P3p1VtQj7WsuWi/y4VnjVBn7F8KPB3I=
 github.com/magiconair/properties v1.8.10 h1:s31yESBquKXCV9a/ScB3ESkOjUYYv+X0rg8SYxI99mE=
 github.com/magiconair/properties v1.8.10/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/mattn/go-localereader v0.0.1 h1:ygSAOl7ZXTx4RdPYinUpg6W99U8jWvWi9Ye2JC/oIi4=
-github.com/mattn/go-localereader v0.0.1/go.mod h1:8fBrzywKY7BI3czFoHkuzRoWE9C+EiG4R1k4Cjx5p88=
-github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
-github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
 github.com/mdelapenya/tlscert v0.2.0 h1:7H81W6Z/4weDvZBNOfQte5GpIMo0lGYEeWbkGp5LJHI=
 github.com/mdelapenya/tlscert v0.2.0/go.mod h1:O4njj3ELLnJjGdkN7M/vIVCpZ+Cf0L6muqOG4tLSl8o=
-github.com/mfridman/interpolate v0.0.2 h1:pnuTK7MQIxxFz1Gr+rjSIx9u7qVjf5VOoM/u6BbAxPY=
-github.com/mfridman/interpolate v0.0.2/go.mod h1:p+7uk6oE07mpE/Ik1b8EckO0O4ZXiGAfshKBWLUM9Xg=
 github.com/moby/docker-image-spec v1.3.1 h1:jMKff3w6PgbfSa69GfNg+zN/XLhfXJGnEx3Nl2EsFP0=
 github.com/moby/docker-image-spec v1.3.1/go.mod h1:eKmb5VW8vQEh/BAr2yvVNvuiJuY6UIocYsFu/DxxRpo=
 github.com/moby/go-archive v0.1.0 h1:Kk/5rdW/g+H8NHdJW2gsXyZ7UnzvJNOy6VKJqueWdcQ=
@@ -158,12 +126,6 @@ github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9G
 github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
 github.com/morikuni/aec v1.0.0 h1:nP9CBfwrvYnBRgY6qfDQkygYDmYwOilePFkwzv4dU8A=
 github.com/morikuni/aec v1.0.0/go.mod h1:BbKIizmSmc5MMPqRYbxO4ZU0S0+P200+tUnFx7PXmsc=
-github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 h1:ZK8zHtRHOkbHy6Mmr5D264iyp3TiX5OmNcI5cIARiQI=
-github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6/go.mod h1:CJlz5H+gyd6CUWT45Oy4q24RdLyn7Md9Vj2/ldJBSIo=
-github.com/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELUXHmA=
-github.com/muesli/cancelreader v0.2.2/go.mod h1:3XuTXfFS2VjM+HTLZY9Ak0l6eUKfijIfMUZ4EgX0QYo=
-github.com/muesli/termenv v0.16.0 h1:S5AlUN9dENB57rsbnkPyfdGuWIlkmzJjbFf0Tf5FWUc=
-github.com/muesli/termenv v0.16.0/go.mod h1:ZRfOIKPFDYQoDFF4Olj7/QJbW60Ol/kL1pU3VfY/Cnk=
 github.com/ncruces/go-strftime v1.0.0 h1:HMFp8mLCTPp341M/ZnA4qaf7ZlsbTc+miZjCLOFAw7w=
 github.com/ncruces/go-strftime v1.0.0/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls=
 github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U=
@@ -178,17 +140,10 @@ github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZb
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/power-devops/perfstat v0.0.0-20210106213030-5aafc221ea8c h1:ncq/mPwQF4JjgDlrVEn3C11VoGHZN7m8qihwgMEtzYw=
 github.com/power-devops/perfstat v0.0.0-20210106213030-5aafc221ea8c/go.mod h1:OmDBASR4679mdNQnz2pUhc2G8CO2JrUAVFDRBDP/hJE=
-github.com/pressly/goose/v3 v3.26.0 h1:KJakav68jdH0WDvoAcj8+n61WqOIaPGgH0bJWS6jpmM=
-github.com/pressly/goose/v3 v3.26.0/go.mod h1:4hC1KrritdCxtuFsqgs1R4AU5bWtTAf+cnWvfhf2DNY=
 github.com/redis/go-redis/v9 v9.17.2 h1:P2EGsA4qVIM3Pp+aPocCJ7DguDHhqrXNhVcEp4ViluI=
 github.com/redis/go-redis/v9 v9.17.2/go.mod h1:u410H11HMLoB+TP67dz8rL9s6QW2j76l0//kSOd3370=
 github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE=
 github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
-github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
-github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/sethvargo/go-retry v0.3.0 h1:EEt31A35QhrcRZtrYFDTBg91cqZVnFL2navjDrah2SE=
-github.com/sethvargo/go-retry v0.3.0/go.mod h1:mNX17F0C/HguQMyMyJxcnU471gOZGxCLyYaFyAZraas=
 github.com/shirou/gopsutil/v4 v4.25.6 h1:kLysI2JsKorfaFPcYmcJqbzROzsBWEOAtw6A7dIfqXs=
 github.com/shirou/gopsutil/v4 v4.25.6/go.mod h1:PfybzyydfZcN+JMMjkF6Zb8Mq1A/VcogFFg7hj50W9c=
 github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
@@ -211,8 +166,6 @@ github.com/tklauser/go-sysconf v0.3.12 h1:0QaGUFOdQaIVdPgfITYzaTegZvdCjmYO52cSFA
 github.com/tklauser/go-sysconf v0.3.12/go.mod h1:Ho14jnntGE1fpdOqQEEaiKRpvIavV0hSfmBq8nJbHYI=
 github.com/tklauser/numcpus v0.6.1 h1:ng9scYS7az0Bk4OZLvrNXNSAO2Pxr1XXRAPyjhIx+Fk=
 github.com/tklauser/numcpus v0.6.1/go.mod h1:1XfjsgE2zo8GVw7POkMbHENHzVg3GzmoZ9fESEdAacY=
-github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no=
-github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJuqunuUZ/Dhy/avygyECGrLceyNeo4LiM=
 github.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo0=
 github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0=
 go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
@@ -225,8 +178,6 @@ go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/Wgbsd
 go.opentelemetry.io/otel/metric v1.37.0/go.mod h1:04wGrZurHYKOc+RKeye86GwKiTb9FKm1WHtO+4EVr2E=
 go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mxVK7z4=
 go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0=
-go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=
-go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
 golang.org/x/crypto v0.48.0 h1:/VRzVqiRSggnhY7gNRxPauEQ5Drw9haKdM0jqfcCFts=
 golang.org/x/crypto v0.48.0/go.mod h1:r0kV5h3qnFPlQnBSrULhlsRfryS2pmewsg+XfMgkVos=
 golang.org/x/exp v0.0.0-20251219203646-944ab1f22d93 h1:fQsdNF2N+/YewlRZiricy4P1iimyPKZ/xwniHj8Q2a0=
@@ -237,7 +188,6 @@ golang.org/x/net v0.50.0 h1:ucWh9eiCGyDR3vtzso0WMQinm2Dnt8cFMuQa9K33J60=
 golang.org/x/net v0.50.0/go.mod h1:UgoSli3F/pBgdJBHCTc+tp3gmrU4XswgGRgtnwWTfyM=
 golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4=
 golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
-golang.org/x/sys v0.0.0-20210809222454-d867a43fc93e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.41.0 h1:Ivj+2Cp/ylzLiEU89QhWblYnOE9zerudt9Ftecq2C6k=
 golang.org/x/sys v0.41.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
@@ -247,7 +197,6 @@ golang.org/x/time v0.14.0 h1:MRx4UaLrDotUKUdCIqzPC48t1Y9hANFKIRpNx+Te8PI=
 golang.org/x/time v0.14.0/go.mod h1:eL/Oa2bBBK0TkX57Fyni+NgnyQQN4LitPmob2Hjnqw4=
 golang.org/x/tools v0.42.0 h1:uNgphsn75Tdz5Ji2q36v/nsFSfR/9BRFvqhGBaJGd5k=
 golang.org/x/tools v0.42.0/go.mod h1:Ma6lCIwGZvHK6XtgbswSoWroEkhugApmsXyrUmBhfr0=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 modernc.org/cc/v4 v4.27.1 h1:9W30zRlYrefrDV2JE2O8VDtJ1yPGownxciz5rrbQZis=
diff --git a/login/login_test.go b/login/login_test.go
index cfd0d73..75d9ac5 100644
--- a/login/login_test.go
+++ b/login/login_test.go
@@ -195,6 +195,31 @@ func TestLoginE2E(t *testing.T) {
 		t.Log("✅ Successful login verified")
 	})
 
+	// Regression guard: before livetemplate's Session.TriggerAction fix,
+	// ctx.Session() returned nil inside OnConnect, so sendWelcomeMessage
+	// silently no-op'd. The page-literal "Welcome, testuser!" (tested above)
+	// is template-rendered and would still be present even with a broken
+	// Session, so only an explicit check for the server-push payload catches
+	// the regression. sendWelcomeMessage sleeps 500ms then calls
+	// session.TriggerAction("serverWelcome", {"message": "Welcome testuser!
+	// This message was pushed from the server at HH:MM:SS"}), which
+	// ServerWelcome renders into the ServerMessage <ins> element.
+	t.Run("Server Welcome Message via WebSocket Push", func(t *testing.T) {
+		// Use the explicit #server-welcome-message id rather than a bare
+		// `ins` selector so the test can't accidentally match a different
+		// <ins> element (e.g., a future generic success flash) and pass
+		// spuriously. The id lives on auth.html line 23.
+		err := chromedp.Run(ctx,
+			e2etest.WaitForText(`#server-welcome-message`, "pushed from the server", 5*time.Second),
+		)
+		if err != nil {
+			var body string
+			_ = chromedp.Run(ctx, chromedp.OuterHTML(`body`, &body, chromedp.ByQuery))
+			t.Fatalf("Server welcome message did not arrive via WebSocket push within 5s: %v\n=== body ===\n%s", err, body[:min(len(body), 800)])
+		}
+		t.Log("✅ Server-pushed welcome message verified")
+	})
+
 	t.Run("Logout via Form Submit", func(t *testing.T) {
 		var html string
 
diff --git a/login/templates/auth.html b/login/templates/auth.html
index f0f5006..72ae59c 100644
--- a/login/templates/auth.html
+++ b/login/templates/auth.html
@@ -20,7 +20,7 @@
         <article>
             <h1>Dashboard</h1>
             {{if .ServerMessage}}
-            <ins style="display:block;text-decoration:none">{{.ServerMessage}}</ins>
+            <ins id="server-welcome-message" style="display:block;text-decoration:none">{{.ServerMessage}}</ins>
             {{end}}
             <section>
                 <p>Welcome, <strong>{{.Username}}</strong>!</p>
diff --git a/patterns/data.go b/patterns/data.go
index 64f5e7b..81da4ec 100644
--- a/patterns/data.go
+++ b/patterns/data.go
@@ -258,9 +258,9 @@ func allPatterns() []PatternCategory {
 		{
 			Name: "Loading & Progress",
 			Patterns: []PatternLink{
-				{Name: "Lazy Loading", Path: "/patterns/loading/lazy-loading", Description: "Load content after page render via server push"},
-				{Name: "Progress Bar", Path: "/patterns/loading/progress-bar", Description: "WebSocket-pushed progress updates"},
-				{Name: "Async Operations", Path: "/patterns/loading/async-operations", Description: "Loading/success/error state machine"},
+				{Name: "Lazy Loading", Path: "/patterns/loading/lazy-loading", Description: "Load content after page render via server push", Implemented: true},
+				{Name: "Progress Bar", Path: "/patterns/loading/progress-bar", Description: "WebSocket-pushed progress updates", Implemented: true},
+				{Name: "Async Operations", Path: "/patterns/loading/async-operations", Description: "Loading/success/error state machine", Implemented: true},
 			},
 		},
 		{
diff --git a/patterns/handlers_loading.go b/patterns/handlers_loading.go
new file mode 100644
index 0000000..62d6637
--- /dev/null
+++ b/patterns/handlers_loading.go
@@ -0,0 +1,304 @@
+package main
+
+import (
+	"math/rand"
+	"net/http"
+	"slices"
+	"time"
+
+	"github.com/livetemplate/livetemplate"
+)
+
+// --- Pattern #14: Lazy Loading ---
+
+// LazyLoadController spawns a goroutine on OnConnect that pushes the lazily-
+// loaded payload via session.TriggerAction after a simulated delay. If the
+// client reconnects after the payload has already arrived, OnConnect is a
+// no-op so the goroutine does not fire a second time.
+type LazyLoadController struct{}
+
+// lazyLoadDelay is how long the simulated "slow API" takes before data arrives.
+const lazyLoadDelay = 2 * time.Second
+
+func (c *LazyLoadController) Mount(state LazyLoadState, ctx *livetemplate.Context) (LazyLoadState, error) {
+	// Guard: Mount also fires on POST actions (e.g., Reload). Without this,
+	// the POST would reset Data/Loading and stomp on the action's own return.
+	if ctx.Action() == "" {
+		state.Loading = true
+		state.Data = ""
+	}
+	return state, nil
+}
+
+func (c *LazyLoadController) OnConnect(state LazyLoadState, ctx *livetemplate.Context) (LazyLoadState, error) {
+	// Skip if the data has already arrived (e.g., reconnect after a network
+	// hiccup) — re-spawning the goroutine would emit a duplicate update.
+	if !state.Loading {
+		return state, nil
+	}
+	// Session is guaranteed non-nil by livetemplate v0.8.18+ (every connect
+	// path wires WithSession). The defensive check stays so a future
+	// framework regression surfaces as "no push happens" rather than a
+	// panic — but it should NOT be confused with the JS-disabled fallback.
+	// JS-disabled clients never reach OnConnect at all (no WebSocket = no
+	// OnConnect call); the JS-disabled spinner-forever case is created by
+	// Mount() returning Loading=true on the initial HTTP GET. The nil
+	// branch here is purely a defensive guard against framework bugs.
+	session := ctx.Session()
+	if session == nil {
+		return state, nil
+	}
+	// Reconnect-during-loading note: if the client disconnects and
+	// reconnects within the 2s window, OnConnect fires again and spawns
+	// a second goroutine while the first is still asleep. Both goroutines
+	// dispatch via groupID lookup (registry.GetByGroup), and groupID is
+	// stable across reconnects (cookie-bound), so when each goroutine
+	// wakes one of two things happens:
+	//   (a) The reconnect hasn't completed yet → GetByGroup returns no
+	//       connections → TriggerAction returns "no connected sessions"
+	//       → goroutine exits via the cancellation pattern below.
+	//   (b) The reconnect has completed → both goroutines successfully
+	//       dispatch to the new connection. DataLoaded runs twice with
+	//       slightly different timestamps; the second call overwrites
+	//       Data. This is harmless — the user just sees the timestamp
+	//       update once. Loading=false is idempotent.
+	// No explicit dedup guard is needed for this demo. Production code
+	// that absolutely requires single-flight semantics should track the
+	// in-flight request ID in state and check it inside DataLoaded.
+	go func() {
+		time.Sleep(lazyLoadDelay)
+		if err := session.TriggerAction("dataLoaded", map[string]any{
+			"data": "Content loaded lazily at " + time.Now().Format("15:04:05"),
+		}); err != nil {
+			return // Session disconnected — stop cleanly.
+		}
+	}()
+	return state, nil
+}
+
+func (c *LazyLoadController) DataLoaded(state LazyLoadState, ctx *livetemplate.Context) (LazyLoadState, error) {
+	state.Data = ctx.GetString("data")
+	state.Loading = false
+	return state, nil
+}
+
+func (c *LazyLoadController) Reload(state LazyLoadState, ctx *livetemplate.Context) (LazyLoadState, error) {
+	// Re-entrancy guard, symmetric with ProgressBarController.Start and
+	// AsyncOpsController.Fetch. The template hides the Reload button while
+	// Loading=true so a click cannot re-trigger this during the 2s window,
+	// but a direct WebSocket message bypassing the rendered UI could —
+	// without this guard, two goroutines would both write state.Data and
+	// the second timestamp would overwrite the first. Harmless for a demo,
+	// but the asymmetry would be a trap for readers pattern-matching from
+	// this file.
+	if state.Loading {
+		return state, nil
+	}
+	// Check session BEFORE mutating state. With livetemplate v0.8.18+ this
+	// is always non-nil, but the early return ensures the UI does not
+	// transition into Loading=true with no goroutine to ever clear it
+	// — which would happen if the framework's session wiring regressed.
+	session := ctx.Session()
+	if session == nil {
+		return state, nil
+	}
+	state.Loading = true
+	state.Data = ""
+	go func() {
+		time.Sleep(lazyLoadDelay)
+		if err := session.TriggerAction("dataLoaded", map[string]any{
+			"data": "Content reloaded at " + time.Now().Format("15:04:05"),
+		}); err != nil {
+			return // Session disconnected — stop cleanly.
+		}
+	}()
+	return state, nil
+}
+
+func lazyLoadingHandler(baseOpts []livetemplate.Option) http.Handler {
+	opts := append(slices.Clone(baseOpts),
+		livetemplate.WithParseFiles("templates/layout.tmpl", "templates/loading/lazy-loading.tmpl"),
+	)
+	tmpl := livetemplate.Must(livetemplate.New("layout", opts...))
+	return tmpl.Handle(&LazyLoadController{}, livetemplate.AsState(&LazyLoadState{
+		Title:    "Lazy Loading",
+		Category: "Loading & Progress",
+	}))
+}
+
+// --- Pattern #15: Progress Bar ---
+
+// ProgressBarController drives a bounded goroutine that ticks progress from
+// 10% to 100% in 10% increments every 500ms. The goroutine exits cleanly if
+// session.TriggerAction returns an error (session disconnected) — this is the
+// canonical cancellation pattern documented in the Server Push pattern (#31).
+//
+// Reconnect semantics — why no OnConnect:
+// ProgressBarState has no `lvt:"persist"` struct tags, so `h.persistable == nil`
+// in the framework and `restorePersistedState` returns (nil, false). On every
+// WebSocket connect (including reconnects after a network blip), mount.go falls
+// through to `cloneStateTyped()` and produces fresh zero-value state
+// (Running=false, Done=false, Progress=0). The "stuck Running=true with no
+// goroutine" scenario therefore cannot occur — reconnecting always shows the
+// Start button again. LazyLoadController needs OnConnect because the spinner
+// vs. data swap is the *whole point* of that pattern; here the pattern is the
+// goroutine ticking the bar, and a mid-run disconnect simply ends that demo
+// (the user clicks Start again on the next page load).
+type ProgressBarController struct{}
+
+const (
+	progressStep     = 10
+	progressTickRate = 500 * time.Millisecond
+)
+
+func (c *ProgressBarController) Start(state ProgressBarState, ctx *livetemplate.Context) (ProgressBarState, error) {
+	// Per-session guard against double-click stacking two goroutines.
+	if state.Running {
+		return state, nil
+	}
+	// Check session BEFORE setting Running=true. With livetemplate v0.8.18+
+	// this is always non-nil, but if it ever became nil the previous
+	// ordering (mutate first, check second) would leave Running=true
+	// permanently and the Running guard above would block all subsequent
+	// Start clicks. Checking first ensures the UI stays interactive.
+	session := ctx.Session()
+	if session == nil {
+		return state, nil
+	}
+	state.Running = true
+	state.Done = false
+	state.Progress = 0
+	go func() {
+		for i := progressStep; i <= 100; i += progressStep {
+			time.Sleep(progressTickRate)
+			if err := session.TriggerAction("updateProgress", map[string]any{
+				"progress": i,
+			}); err != nil {
+				return // Session disconnected — stop cleanly.
+			}
+		}
+	}()
+	return state, nil
+}
+
+func (c *ProgressBarController) UpdateProgress(state ProgressBarState, ctx *livetemplate.Context) (ProgressBarState, error) {
+	state.Progress = ctx.GetInt("progress")
+	if state.Progress >= 100 {
+		state.Running = false
+		state.Done = true
+		ctx.SetFlash("success", "Job complete")
+	}
+	return state, nil
+}
+
+func progressBarHandler(baseOpts []livetemplate.Option) http.Handler {
+	opts := append(slices.Clone(baseOpts),
+		livetemplate.WithParseFiles("templates/layout.tmpl", "templates/loading/progress-bar.tmpl"),
+	)
+	tmpl := livetemplate.Must(livetemplate.New("layout", opts...))
+	return tmpl.Handle(&ProgressBarController{}, livetemplate.AsState(&ProgressBarState{
+		Title:    "Progress Bar",
+		Category: "Loading & Progress",
+	}))
+}
+
+// --- Pattern #16: Async Operations ---
+
+// AsyncOpsController implements a loading/success/error state machine. The
+// Fetch action transitions to "loading" synchronously, then a goroutine waits
+// and pushes a "fetchResult" action with either a success payload or an error
+// payload. Demonstrates the minimal state-machine shape you'd use for any
+// async RPC (database query, HTTP API, job queue, etc.).
+//
+// Reconnect semantics — why no OnConnect (same reasoning as ProgressBarController):
+// AsyncOpsState has no `lvt:"persist"` tags, so a reconnect mid-fetch produces
+// fresh zero-value state (Status="") via cloneStateTyped, not a stuck
+// Status="loading". The user always sees the Fetch Data button after a
+// reconnect. The in-flight goroutine's eventual TriggerAction either lands on
+// the new connection (showing a result the user didn't initiate — harmless,
+// since this is a demo) or errors out cleanly when the goroutine's session
+// is gone. Adding OnConnect to "recover" loading state would actively make
+// this worse by trying to restore Status="loading" against a goroutine that
+// the framework has already torn down.
+type AsyncOpsController struct{}
+
+const asyncFetchDelay = 2 * time.Second
+
+func (c *AsyncOpsController) Fetch(state AsyncOpsState, ctx *livetemplate.Context) (AsyncOpsState, error) {
+	// Re-entrancy guard: block concurrent Fetch while one is already in
+	// flight. The button is template-disabled during loading, but a direct
+	// WebSocket message bypassing the rendered UI could otherwise spawn
+	// two parallel goroutines that both call TriggerAction("fetchResult"),
+	// producing two state transitions and two SetFlash calls on the same
+	// session. Mirrors the Running guard in ProgressBarController.Start.
+	if state.Status == "loading" {
+		return state, nil
+	}
+	// Check session BEFORE setting Status="loading". With livetemplate
+	// v0.8.18+ this is always non-nil, but if it ever became nil the
+	// previous ordering (mutate first, check second) would leave the
+	// button stuck showing "Fetching..." with no goroutine to clear it.
+	session := ctx.Session()
+	if session == nil {
+		return state, nil
+	}
+	state.Status = "loading"
+	state.Result = ""
+	state.Error = ""
+	go func() {
+		time.Sleep(asyncFetchDelay)
+		// Simulated ~33% failure rate. Non-deterministic between runs because
+		// Go 1.20+ auto-seeds top-level math/rand from a system source at
+		// program startup — no rand.Seed call is needed. Tests must assert
+		// {success OR error}, not a specific branch, since either may fire
+		// on any given run.
+		//
+		// Both branches use the same `if err := …; err != nil { return }`
+		// pattern as the other controllers for consistency, even though
+		// this is a single-shot goroutine where there's nothing else to
+		// cancel — readers learning the pattern from this example should
+		// see the idiomatic form everywhere.
+		if rand.Intn(3) == 0 {
+			if err := session.TriggerAction("fetchResult", map[string]any{
+				"success": false,
+				"error":   "Connection timed out",
+			}); err != nil {
+				return // Session disconnected — stop cleanly.
+			}
+		} else {
+			if err := session.TriggerAction("fetchResult", map[string]any{
+				"success": true,
+				"result":  "Data fetched successfully at " + time.Now().Format("15:04:05"),
+			}); err != nil {
+				return // Session disconnected — stop cleanly.
+			}
+		}
+	}()
+	return state, nil
+}
+
+func (c *AsyncOpsController) FetchResult(state AsyncOpsState, ctx *livetemplate.Context) (AsyncOpsState, error) {
+	if ctx.GetBool("success") {
+		state.Status = "success"
+		state.Result = ctx.GetString("result")
+		state.Error = ""
+		ctx.SetFlash("success", "Fetch complete")
+	} else {
+		state.Status = "error"
+		state.Error = ctx.GetString("error")
+		state.Result = ""
+		ctx.SetFlash("error", "Fetch failed")
+	}
+	return state, nil
+}
+
+func asyncOperationsHandler(baseOpts []livetemplate.Option) http.Handler {
+	opts := append(slices.Clone(baseOpts),
+		livetemplate.WithParseFiles("templates/layout.tmpl", "templates/loading/async-operations.tmpl"),
+	)
+	tmpl := livetemplate.Must(livetemplate.New("layout", opts...))
+	return tmpl.Handle(&AsyncOpsController{}, livetemplate.AsState(&AsyncOpsState{
+		Title:    "Async Operations",
+		Category: "Loading & Progress",
+	}))
+}
diff --git a/patterns/main.go b/patterns/main.go
index 049d208..ff0455d 100644
--- a/patterns/main.go
+++ b/patterns/main.go
@@ -85,6 +85,11 @@ func main() {
 	mux.Handle("/patterns/search/active-search", activeSearchHandler(baseOpts))
 	mux.Handle("/patterns/search/url-filters", urlFiltersHandler(baseOpts))
 
+	// Category: Loading & Progress (#14–#16)
+	mux.Handle("/patterns/loading/lazy-loading", lazyLoadingHandler(baseOpts))
+	mux.Handle("/patterns/loading/progress-bar", progressBarHandler(baseOpts))
+	mux.Handle("/patterns/loading/async-operations", asyncOperationsHandler(baseOpts))
+
 	// Client library and CSS (dev mode)
 	if localClient := os.Getenv("LVT_LOCAL_CLIENT"); localClient != "" {
 		mux.HandleFunc("/livetemplate-client.js", func(w http.ResponseWriter, r *http.Request) {
diff --git a/patterns/patterns_test.go b/patterns/patterns_test.go
index d341820..1e181b9 100644
--- a/patterns/patterns_test.go
+++ b/patterns/patterns_test.go
@@ -1457,3 +1457,299 @@ func TestInfiniteScroll(t *testing.T) {
 		}
 	})
 }
+
+// --- Session 3: Loading & Progress ---
+
+func TestLazyLoading(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Skipping E2E test in short mode")
+	}
+
+	ctx, cancel, serverPort := setupTest(t)
+	defer cancel()
+
+	url := e2etest.GetChromeTestURL(serverPort) + "/patterns/loading/lazy-loading"
+
+	t.Run("Initial_Load_Shows_Spinner", func(t *testing.T) {
+		// The page should render immediately with the spinner; the content
+		// blockquote must be absent until the goroutine fires (~2s later).
+		var hasBlockquote bool
+		err := chromedp.Run(ctx,
+			chromedp.Navigate(url),
+			e2etest.WaitForWebSocketReady(5*time.Second),
+			chromedp.WaitVisible(`p[aria-busy="true"]`, chromedp.ByQuery),
+			e2etest.ValidateNoTemplateExpressions("[data-lvt-id]"),
+			chromedp.Evaluate(`!!document.querySelector('blockquote')`, &hasBlockquote),
+		)
+		if err != nil {
+			t.Fatalf("Initial load failed: %v", err)
+		}
+		if hasBlockquote {
+			t.Error("Blockquote should not be present while still loading")
+		}
+	})
+
+	t.Run("Data_Arrives_Via_Server_Push", func(t *testing.T) {
+		// The goroutine sleeps 2s then pushes via TriggerAction. 5s timeout
+		// is generous. After arrival, the spinner must be gone.
+		var hasSpinner bool
+		err := chromedp.Run(ctx,
+			e2etest.WaitForText(`blockquote`, "Content loaded lazily", 5*time.Second),
+			chromedp.Evaluate(`!!document.querySelector('p[aria-busy="true"]')`, &hasSpinner),
+		)
+		if err != nil {
+			t.Fatalf("Data did not arrive: %v", err)
+		}
+		if hasSpinner {
+			t.Error("Spinner should be gone after data arrives")
+		}
+	})
+
+	t.Run("Reload_Refetches_Fresh_Content", func(t *testing.T) {
+		// Click Reload; spinner reappears; new content arrives via a fresh
+		// goroutine push. The two strings have different prefixes ("Content
+		// loaded lazily at …" vs "Content reloaded at …"), so an inequality
+		// check between them is trivially true and would not actually prove
+		// that a second goroutine ran. Instead, assert directly on the
+		// expected prefix transitions: firstContent must be the
+		// initial-load message, secondContent must be the reload message.
+		// Both prefixes are produced by separate goroutine paths, so this
+		// assertion proves real second-goroutine execution.
+		var firstContent, secondContent string
+		err := chromedp.Run(ctx,
+			chromedp.Text(`blockquote`, &firstContent, chromedp.ByQuery),
+			chromedp.Click(`button[name="reload"]`, chromedp.ByQuery),
+			chromedp.WaitVisible(`p[aria-busy="true"]`, chromedp.ByQuery),
+			e2etest.WaitForText(`blockquote`, "Content reloaded", 5*time.Second),
+			chromedp.Text(`blockquote`, &secondContent, chromedp.ByQuery),
+		)
+		if err != nil {
+			t.Fatalf("Reload failed: %v", err)
+		}
+		if !strings.Contains(firstContent, "Content loaded lazily") {
+			t.Errorf("First content was not the initial load message: %q", firstContent)
+		}
+		if strings.Contains(firstContent, "Content reloaded") {
+			t.Errorf("First content already had the reload prefix — test ordering broken: %q", firstContent)
+		}
+		if !strings.Contains(secondContent, "Content reloaded") {
+			t.Errorf("Second content did not have the reload prefix: %q", secondContent)
+		}
+		if strings.Contains(secondContent, "Content loaded lazily") {
+			t.Errorf("Second content still had the initial-load prefix: %q", secondContent)
+		}
+	})
+
+	runStandardSubtests(t, ctx, false, "Lazy Loading — page showing a blockquote with lazily-loaded content and a secondary 'Reload' button below")
+}
+
+func TestProgressBar(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Skipping E2E test in short mode")
+	}
+
+	ctx, cancel, serverPort := setupTest(t)
+	defer cancel()
+
+	url := e2etest.GetChromeTestURL(serverPort) + "/patterns/loading/progress-bar"
+
+	t.Run("Initial_Load", func(t *testing.T) {
+		var hasProgress bool
+		err := chromedp.Run(ctx,
+			chromedp.Navigate(url),
+			e2etest.WaitForWebSocketReady(5*time.Second),
+			chromedp.WaitVisible(`button[name="start"]`, chromedp.ByQuery),
+			e2etest.ValidateNoTemplateExpressions("[data-lvt-id]"),
+			chromedp.Evaluate(`!!document.querySelector('progress')`, &hasProgress),
+		)
+		if err != nil {
+			t.Fatalf("Initial load failed: %v", err)
+		}
+		if hasProgress {
+			t.Error("<progress> should not be present before Start is clicked")
+		}
+	})
+
+	t.Run("Start_Runs_To_Completion", func(t *testing.T) {
+		// Click Start; progress element appears and ticks up. Goroutine runs
+		// 10 × 500ms = 5s, so wait 10s for completion and the success flash.
+		// The intermediate-tick assertion (value > 0 AND value < 100) catches
+		// a regression where the goroutine skips intermediate ticks and jumps
+		// straight to 100 — a `value > 0` check alone would also be satisfied
+		// by an instant 100, missing the bug.
+		err := chromedp.Run(ctx,
+			chromedp.Click(`button[name="start"]`, chromedp.ByQuery),
+			e2etest.WaitFor(`!!document.querySelector('progress')`, 3*time.Second),
+			// Progress element is mid-flight: above 0 and below 100.
+			// This proves the goroutine is actually ticking, not jumping.
+			// 5s timeout (matching Run_Again_Restarts_Timer) gives loaded
+			// CI runners a comfortable margin before the goroutine completes
+			// the full 5s run and the value reaches 100.
+			e2etest.WaitFor(`document.querySelector('progress') && document.querySelector('progress').value > 0 && document.querySelector('progress').value < 100`, 5*time.Second),
+			// Run Again button indicates the Done state.
+			e2etest.WaitForText(`button`, "Run Again", 10*time.Second),
+			e2etest.WaitForText(`output[data-flash="success"]`, "Job complete", 3*time.Second),
+		)
+		if err != nil {
+			t.Fatalf("Progress bar did not complete: %v", err)
+		}
+	})
+
+	t.Run("Run_Again_Restarts_Timer", func(t *testing.T) {
+		// The Run Again button starts the timer again. Progress must begin
+		// from below 100, climb back to completion, AND re-emit the success
+		// flash. The flash assertion catches a regression where the second
+		// run completes silently (e.g., if the controller forgot to call
+		// SetFlash on the re-completion path).
+		//
+		// The intermediate-tick timeout is 5s (not 3s) so that on a heavily
+		// loaded CI runner, where the first WS tick may be delayed, we still
+		// catch a real value < 100 before the goroutine completes the full
+		// 5s run. 3s was tight enough that a slow runner could miss the
+		// window even though the goroutine was working correctly.
+		err := chromedp.Run(ctx,
+			chromedp.Click(`button[name="start"]`, chromedp.ByQuery),
+			e2etest.WaitFor(`document.querySelector('progress') && document.querySelector('progress').value > 0 && document.querySelector('progress').value < 100`, 5*time.Second),
+			e2etest.WaitForText(`button`, "Run Again", 10*time.Second),
+			e2etest.WaitForText(`output[data-flash="success"]`, "Job complete", 3*time.Second),
+		)
+		if err != nil {
+			t.Fatalf("Run Again failed: %v", err)
+		}
+	})
+
+	runStandardSubtests(t, ctx, false, "Progress Bar — completed state showing a full progress bar, a 'Job complete' success flash below it, and a 'Run Again' button")
+}
+
+func TestAsyncOperations(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Skipping E2E test in short mode")
+	}
+
+	ctx, cancel, serverPort := setupTest(t)
+	defer cancel()
+
+	url := e2etest.GetChromeTestURL(serverPort) + "/patterns/loading/async-operations"
+
+	t.Run("Initial_Load", func(t *testing.T) {
+		var hasResult bool
+		err := chromedp.Run(ctx,
+			chromedp.Navigate(url),
+			e2etest.WaitForWebSocketReady(5*time.Second),
+			e2etest.WaitForText(`button[name="fetch"]`, "Fetch Data", 3*time.Second),
+			e2etest.ValidateNoTemplateExpressions("[data-lvt-id]"),
+			chromedp.Evaluate(`!!document.querySelector('blockquote') || !!document.querySelector('mark')`, &hasResult),
+		)
+		if err != nil {
+			t.Fatalf("Initial load failed: %v", err)
+		}
+		if hasResult {
+			t.Error("Result/error display should not be present before Fetch is clicked")
+		}
+	})
+
+	t.Run("Fetch_Transitions_Through_Loading_To_Result", func(t *testing.T) {
+		// Click Fetch → transient loading state → final success OR error.
+		// The branch is random (~33% error rate). Tests must tolerate either.
+		err := chromedp.Run(ctx,
+			chromedp.Click(`button[name="fetch"]`, chromedp.ByQuery),
+			// Loading state: button shows "Fetching..." and aria-busy.
+			e2etest.WaitForText(`button[name="fetch"]`, "Fetching...", 3*time.Second),
+			// Final state: either <blockquote> (success) or <mark> (error).
+			e2etest.WaitFor(`!!document.querySelector('blockquote') || !!document.querySelector('mark')`, 5*time.Second),
+			// Button must re-enable (exits "loading" status).
+			e2etest.WaitForText(`button[name="fetch"]`, "Fetch Data", 3*time.Second),
+		)
+		if err != nil {
+			t.Fatalf("Async flow did not complete: %v", err)
+		}
+		// Exactly one of success or error must be present, plus the matching
+		// flash. The flash text is asserted against the controller's exact
+		// SetFlash message, not just the element presence — an empty
+		// <output data-flash=""> placeholder would satisfy a presence-only
+		// check and silently mask a regression where SetFlash wasn't called.
+		//
+		// `outcome` is read first, then both the wait-for-flash and the
+		// flash-text read are batched into a single chromedp.Run so the
+		// outcome value can't drift between the read and the wait.
+		var outcome string
+		err = chromedp.Run(ctx, chromedp.Evaluate(`(() => {
+			if (document.querySelector('blockquote')) return 'success';
+			if (document.querySelector('mark')) return 'error';
+			return 'none';
+		})()`, &outcome))
+		if err != nil {
+			t.Fatalf("Failed to read outcome: %v", err)
+		}
+		if outcome == "none" {
+			t.Fatal("No outcome (neither success nor error) rendered")
+		}
+		// Map outcome → expected flash text from the controller.
+		// Mirrors AsyncOpsController.FetchResult ctx.SetFlash calls.
+		expectedFlashText := map[string]string{
+			"success": "Fetch complete",
+			"error":   "Fetch failed",
+		}[outcome]
+		flashSelector := fmt.Sprintf(`output[data-flash="%s"]`, outcome)
+		var flashText string
+		err = chromedp.Run(ctx,
+			e2etest.WaitFor(fmt.Sprintf(`!!document.querySelector('%s')`, flashSelector), 3*time.Second),
+			chromedp.Evaluate(
+				fmt.Sprintf(`(() => { const el = document.querySelector('%s'); return el ? el.textContent.trim() : ""; })()`, flashSelector),
+				&flashText,
+			),
+		)
+		if err != nil {
+			t.Fatalf("Outcome %q: failed to read %s: %v", outcome, flashSelector, err)
+		}
+		if !strings.Contains(flashText, expectedFlashText) {
+			t.Errorf("Outcome %q: flash text = %q, want it to contain %q", outcome, flashText, expectedFlashText)
+		}
+	})
+
+	// Regression test for the AsyncOpsController.Fetch Running guard.
+	// Without the guard, two rapid `fetch` actions sent via direct
+	// WebSocket message (bypassing the template-disabled button) would
+	// each spawn a goroutine that calls TriggerAction("fetchResult"),
+	// resulting in two state transitions, two SetFlash calls, and
+	// potentially malformed rendered state. With the guard, the second
+	// Fetch is a no-op (state.Status == "loading" → return early).
+	//
+	// This test asserts the user-visible invariant: concurrent Fetch
+	// calls leave the UI in a single consistent state with exactly one
+	// result element (blockquote OR mark, never both, never stacked).
+	// It does not directly verify the guard rejected the second call —
+	// detecting that from the rendered HTML is hard because the state
+	// machine is idempotent in its final state — but it does prove the
+	// guard's user-visible promise (concurrent Fetches don't break the
+	// page) holds.
+	t.Run("Concurrent_Fetch_Reaches_Single_Result", func(t *testing.T) {
+		var resultCount int
+		err := chromedp.Run(ctx,
+			// Wait for idle state from the previous subtest.
+			e2etest.WaitForText(`button[name="fetch"]`, "Fetch Data", 3*time.Second),
+			// Send two Fetch actions in immediate sequence via direct WS,
+			// bypassing the rendered button (which would be disabled
+			// after the first click).
+			chromedp.Evaluate(`(() => {
+				window.liveTemplateClient.send({action: 'fetch'});
+				window.liveTemplateClient.send({action: 'fetch'});
+			})()`, nil),
+			// Wait for the cycle to complete: button returns to "Fetch Data".
+			// Total time: ~2s for the goroutine sleep + WS roundtrip.
+			e2etest.WaitForText(`button[name="fetch"]`, "Fetch Data", 5*time.Second),
+			// Count result elements. Exactly one of (blockquote, mark) must
+			// be present. If two goroutines somehow corrupted the state
+			// machine, we might see zero, two of either, or both.
+			chromedp.Evaluate(`document.querySelectorAll('blockquote, mark').length`, &resultCount),
+		)
+		if err != nil {
+			t.Fatalf("Concurrent Fetch test failed: %v", err)
+		}
+		if resultCount != 1 {
+			t.Errorf("Expected exactly 1 result element after concurrent Fetch, got %d", resultCount)
+		}
+	})
+
+	runStandardSubtests(t, ctx, false, "Async Operations — 'Fetch Data' button followed by either a success flash and blockquote with fetch result, or an error flash and mark element with an error message")
+}
diff --git a/patterns/state_loading.go b/patterns/state_loading.go
new file mode 100644
index 0000000..0ef8100
--- /dev/null
+++ b/patterns/state_loading.go
@@ -0,0 +1,28 @@
+package main
+
+// LazyLoadState holds the state for the Lazy Loading pattern (#14).
+type LazyLoadState struct {
+	Title    string
+	Category string
+	Loading  bool
+	Data     string
+}
+
+// ProgressBarState holds the state for the Progress Bar pattern (#15).
+type ProgressBarState struct {
+	Title    string
+	Category string
+	Progress int
+	Running  bool
+	Done     bool
+}
+
+// AsyncOpsState holds the state for the Async Operations pattern (#16).
+// Status is a simple state machine: "" (idle), "loading", "success", "error".
+type AsyncOpsState struct {
+	Title    string
+	Category string
+	Status   string
+	Result   string
+	Error    string
+}
diff --git a/patterns/templates/loading/async-operations.tmpl b/patterns/templates/loading/async-operations.tmpl
new file mode 100644
index 0000000..2c6c8e3
--- /dev/null
+++ b/patterns/templates/loading/async-operations.tmpl
@@ -0,0 +1,21 @@
+{{define "content"}}
+<article>
+    <h3>Async Operations</h3>
+    <p><small>A loading → success / error state machine. ~33% simulated failure rate on each fetch.</small></p>
+    <form method="POST">
+        <button name="fetch"
+            {{if eq .Status "loading"}}aria-busy="true" disabled{{end}}>
+            {{if eq .Status "loading"}}Fetching...{{else}}Fetch Data{{end}}
+        </button>
+    </form>
+    {{.lvt.FlashTag "success"}}
+    {{.lvt.FlashTag "error"}}
+    {{with .Result}}<blockquote>{{.}}</blockquote>{{end}}
+    {{/* <mark> is the sanctioned choice for secondary inline error details
+         (see CLAUDE.md "Use <mark> for highlighted/badge text and for
+         secondary inline error details"). The FlashTag above is the
+         primary error alert with role="alert"; <mark> highlights the
+         specific error string. */}}
+    {{with .Error}}<p aria-live="assertive"><mark>{{.}}</mark></p>{{end}}
+</article>
+{{end}}
diff --git a/patterns/templates/loading/lazy-loading.tmpl b/patterns/templates/loading/lazy-loading.tmpl
new file mode 100644
index 0000000..8889e5c
--- /dev/null
+++ b/patterns/templates/loading/lazy-loading.tmpl
@@ -0,0 +1,17 @@
+{{define "content"}}
+<article>
+    <h3>Lazy Loading</h3>
+    <p><small>The page renders immediately; content arrives from the server ~2s later via a goroutine pushing <code>session.TriggerAction</code>.</small></p>
+    <noscript>
+        <p><small>This pattern requires JavaScript: the spinner is replaced when a WebSocket message arrives. With JS disabled, the spinner stays forever.</small></p>
+    </noscript>
+    {{if .Loading}}
+    <p aria-busy="true">Loading content...</p>
+    {{else}}
+    <blockquote>{{.Data}}</blockquote>
+    <form method="POST">
+        <button name="reload" class="secondary">Reload</button>
+    </form>
+    {{end}}
+</article>
+{{end}}
diff --git a/patterns/templates/loading/progress-bar.tmpl b/patterns/templates/loading/progress-bar.tmpl
new file mode 100644
index 0000000..8232566
--- /dev/null
+++ b/patterns/templates/loading/progress-bar.tmpl
@@ -0,0 +1,26 @@
+{{define "content"}}
+<article>
+    <h3>Progress Bar</h3>
+    <p><small>A background goroutine ticks progress from 10% to 100% via WebSocket pushes — no polling.</small></p>
+    {{if or .Running .Done}}
+    <progress value="{{.Progress}}" max="100"></progress>
+    <p><small>{{.Progress}}% complete</small></p>
+    {{end}}
+    {{if .Done}}
+    {{/* FlashTag must live inside the .Done branch: UpdateProgress emits
+         the flash only when transitioning to Done, so they always render
+         together. Flashes are ephemeral (consumed on first render) — moving
+         this outside the branch would cause the flash to be consumed during
+         a Running or idle render before Done is reached, and the user would
+         never see it. */}}
+    {{.lvt.FlashTag "success"}}
+    <form method="POST">
+        <button name="start">Run Again</button>
+    </form>
+    {{else if not .Running}}
+    <form method="POST">
+        <button name="start">Start Job</button>
+    </form>
+    {{end}}
+</article>
+{{end}}