diff --git a/scripts/demo-session/README.md b/scripts/demo-session/README.md
new file mode 100644
index 0000000000..e3a320d753
--- /dev/null
+++ b/scripts/demo-session/README.md
@@ -0,0 +1,156 @@
+# Demo sessions
+
+Tooling for live user-testing sessions: one command starts an isolated
+atomic-server and data-browser for a branch, with demo data seeded and a
+dev-only interaction log that an observer (a person, or an agent using a
+file-tail monitor) can follow while the tester works.
+
+```sh
+scripts/demo-session/demo-session.sh develop
+```
+
+Then open the printed URL,
+`http://localhost:6757/app/dev-drive?demo-seed=calendar`. That page makes a
+fresh agent and drive in the browser, so there is no signup and no secret to
+type. The seed then builds the demo tables and opens the first one, which takes
+about 3 seconds.
+
+## What it does
+
+1. Uses the branch's existing worktree, or creates one under
+   `~/.cache/atomic-demo/worktrees/`.
+2. Builds what is missing or stale:
+   - `pnpm install`
+   - the workspace packages the data-browser imports from `dist/`
+   - the wasm pair, cached by the git trees of `wasm/` and `lib/`
+   - `cargo build -p atomic-server`, with `SKIP_WASM_BUILD=1` and
+     `ATOMICSERVER_SKIP_JS_BUILD=true`
+
+   The server embeds a placeholder page instead of a production frontend build,
+   because the app is served by Vite. Pass `--no-build` to skip this step.
+3. Starts atomic-server on port 9893 with a fresh data, config and cache dir.
+4. Starts Vite on port 6757 against that server, with the interaction logger.
+
+Each run writes to its own folder, `~/.cache/atomic-demo/sessions/<stamp>-<branch>/`,
+and `sessions/latest` points at the newest one:
+
+| File          | Contents                                           |
+| ------------- | -------------------------------------------------- |
+| `ux.jsonl`    | the interaction log, one JSON object per line      |
+| `server.log`  | atomic-server output                               |
+| `vite.log`    | Vite output, including compile errors              |
+| `session.env` | branch, commit, URLs                               |
+| `data/`       | the store; delete the folder to throw it away      |
+
+Ctrl-C stops both processes and keeps the folder.
+
+## The interaction log
+
+`uxLogPlugin.ts` is a Vite plugin with `apply: 'serve'`. It is only added
+when `VITE_UX_LOG=true`, by the config the script generates, so it cannot end
+up in a production build. The plugin injects `uxLogClient.js` into the page,
+and the client posts batches to `/__ux-log` on the Vite server, which appends
+them to `ux.jsonl`. It records:
+
+- clicks, with visible text, accessible label, role, `data-testid`, the
+  enclosing test id and calendar date, and a short selector
+- committed input values, Enter and Escape. Values are cut to 80 characters.
+  Password fields and fields labelled secret, key, token or password are
+  recorded as `[redacted]`.
+- route changes and page loads
+- dialogs and toasts as they become visible
+- `console.error` and `console.warn`, uncaught errors, unhandled rejections,
+  failed resource loads and Vite error overlays
+- failed fetches (with status and the first 80 characters of the body),
+  fetches slower than 3 s, and WebSocket closes that were not clean
+
+Follow it with, for example:
+
+```sh
+tail -f ~/.cache/atomic-demo/sessions/latest/ux.jsonl
+```
+
+Not recorded: typing before a field is committed, scrolling, hovering, or
+what is on screen. Use screenshots for those.
+
+## Seeds
+
+`seed.js` runs in the page through the app's own creation code
+(`buildTableFromSpec`, `createPropertyOnClass`), so it exercises the same
+paths as the UI. It can also be run by hand from the console:
+`await window.__demoSeed('calendar')`.
+
+`calendar` creates:
+
+- **Team calendar**: calendar and table views. Its columns use the shortnames
+  the calendar view reads ranges and recurrence from (`atomic-calendar-day`,
+  `-all-day`, `-end-day`, `-notes`, `-recurrence`). It has 17 rows:
+  - recurring events: weekly on several days with an `UNTIL` and an `EXDATE`,
+    one instance moved to another day, biweekly with a `COUNT`, the first
+    Tuesday of each month, an all-day monthly event, a two-day quarterly event,
+    a yearly event, and a weekly New York meeting that falls on the next day
+    in Amsterdam
+  - single events: all-day, multi-day, one across a month boundary, one on
+    the European clock change (25 Oct 2026), one all-day without an end day,
+    one in January 2027, and one without a date
+- **Content plan**: a table with a `Publish date` column and no calendar view
+  yet, for testing how a user adds one.
+
+## Drive apps (`--plugin`)
+
+```sh
+scripts/demo-session/demo-session.sh <atomic-plugins pin> --plugin issue-tracker \
+  --plugins-dir ~/.cache/atomic-demo/atomic-plugins
+```
+
+`--plugin NAME` uses an atomic-plugins checkout (`--plugins-dir`, with
+`browser/` linked by its `integrations/tooling/link-atomic-server.mjs`). It:
+
+1. builds `integrations/NAME/app/build.mjs` into the session folder
+   (`plugin-app.js`, served to the page at `/__demo-plugin/app.js`);
+2. starts `integrations/localthought/mock-proxy.mjs` on `--mock-port`
+   (default: `--port` + 10000) with `MOCK_SCENARIO=user-testing` (change it
+   with `--mock-scenario`), and points the server
+   (`ATOMIC_INTEGRATION_PROXY_URL`) and Vite (`VITE_INTEGRATION_PROXY_URL`)
+   at it. The mock's `/connect` returns to the Vite origin;
+3. seeds NAME: the app is installed with `createApp` and `handOverAppKey`,
+   as "New app" does, but with the built source instead of the starter.
+
+The provider data comes from the mock's fixture, not from the seed. Its
+drivers change the provider side mid-session:
+`curl -X POST http://127.0.0.1:<mock-port>/fixture/<platform>/<driver> -d '[...]'`.
+To rebuild the app mid-session, run the build line the script prints, then
+reload the page.
+
+Only `issue-tracker` has a seed so far. Known limits:
+
+- **Not in the desktop app's browser pane.** The pane fails every
+  `<iframe sandbox>` load with `net::ERR_BLOCKED_BY_CLIENT`, and drive apps
+  always run in one, so they show a blank panel. Use Chrome.
+- **Connect needs a local host patch.** Under React StrictMode, which only the
+  Vite dev build has, `ProxyConnectReturn` runs its effect twice: the first
+  run redeems the connection code, the second finds it used and shows "This
+  connection return is not one this browser started." Share one redemption
+  per `integration_state` in the worktree under test until the host fixes it.
+- The interaction log sees only the host page, never inside the app's frame.
+
+## Running a session
+
+- **Keep the browser pane visible.** In the Claude desktop app the app is
+  opened in the built-in browser pane beside the chat, not in Chrome. Closing
+  windows hides the pane, and the agent can't unhide it. Tell the tester where
+  its toggle is before the first task.
+- **Phone width:** ask the tester to drag the divider until the pane is about
+  400 px wide. The agent's viewport emulation is reset when its turn ends, so
+  the tester can't use it.
+- **Seeds:** put only what a real user would write in names and notes. Keep
+  explanations of edge cases in code comments, where the tester can't read
+  them.
+- **Clicks in a table** are logged with `cell: {row, column, rowIndex}`
+  (row = the first column's text, column = the header).
+
+## Ports and parallel sessions
+
+`--port` and `--vite-port` pick other ports. Two sessions on the same branch
+share one worktree, and so they share its Vite translation catalogs (see
+AGENTS.md). Run a second branch instead of a second session on the same one.
diff --git a/scripts/demo-session/demo-session.sh b/scripts/demo-session/demo-session.sh
new file mode 100755
index 0000000000..d71ad9feef
--- /dev/null
+++ b/scripts/demo-session/demo-session.sh
@@ -0,0 +1,354 @@
+#!/usr/bin/env bash
+#
+# Start an isolated atomic-server + data-browser for a live user-testing
+# session, with the dev-only interaction logger on and demo data seeded.
+#
+#   scripts/demo-session/demo-session.sh [branch] [options]
+#
+#   branch            atomic-server branch or commit to test (default: the
+#                     branch this script's checkout is on). Uses that branch's
+#                     existing worktree if there is one, else makes one under
+#                     $DEMO_HOME/worktrees/ (detached, for a commit).
+#   --port N          atomic-server port (default 9893)
+#   --vite-port N     Vite dev server port (default 6757)
+#   --seed NAME       seed to run on first open (default: calendar; "none" to skip)
+#   --no-build        start from what is already built
+#   --build-only      build, then exit without starting anything
+#   --plugin NAME     also build atomic-plugins' integrations/NAME/app, start
+#                     the mock integration proxy, and seed NAME (installs the
+#                     drive app into the fresh drive). Default seed becomes NAME.
+#   --plugins-dir DIR the atomic-plugins checkout for --plugin, with browser/
+#                     linked (integrations/tooling/link-atomic-server.mjs);
+#                     default $DEMO_HOME/atomic-plugins
+#   --mock-port N     mock integration proxy port (default: --port + 10000)
+#   --mock-scenario S MOCK_SCENARIO for the mock's fixtures (default:
+#                     user-testing; "default" for the fixtures CI uses)
+#
+# Every run gets a fresh data dir under $DEMO_HOME/sessions/<stamp>-<branch>/,
+# next to server.log, vite.log and ux.jsonl (the interaction log). Ctrl-C
+# stops both processes; the session dir is kept for the findings report.
+#
+# The tooling (this script, the logger plugin and client, and the seeds)
+# always comes from THIS checkout, so it works against branches that predate
+# it. See README.md next to this file.
+set -euo pipefail
+
+TOOLING="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_ROOT="$(cd "$TOOLING/../.." && pwd)"
+DEMO_HOME="${DEMO_HOME:-$HOME/.cache/atomic-demo}"
+PORT=9893
+VITE_PORT=6757
+SEED=calendar
+BUILD=1
+BUILD_ONLY=0
+BRANCH=""
+PLUGIN=""
+PLUGINS_DIR="$DEMO_HOME/atomic-plugins"
+MOCK_PORT=""
+MOCK_SCENARIO=user-testing
+SEED_SET=0
+
+log() { printf '\033[36m[demo]\033[0m %s\n' "$*"; }
+die() { printf '\033[31m[demo]\033[0m %s\n' "$*" >&2; exit 1; }
+
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --port) PORT="$2"; shift 2 ;;
+    --vite-port) VITE_PORT="$2"; shift 2 ;;
+    --seed) SEED="$2"; SEED_SET=1; shift 2 ;;
+    --plugin) PLUGIN="$2"; shift 2 ;;
+    --plugins-dir) PLUGINS_DIR="$2"; shift 2 ;;
+    --mock-port) MOCK_PORT="$2"; shift 2 ;;
+    --mock-scenario) MOCK_SCENARIO="$2"; shift 2 ;;
+    --no-build) BUILD=0; shift ;;
+    --build-only) BUILD_ONLY=1; shift ;;
+    -h|--help) sed -n '2,33p' "$0"; exit 0 ;;
+    -*) die "Unknown option $1" ;;
+    *) BRANCH="$1"; shift ;;
+  esac
+done
+
+BRANCH="${BRANCH:-$(git -C "$REPO_ROOT" rev-parse --abbrev-ref HEAD)}"
+SLUG="$(printf '%s' "$BRANCH" | tr -c 'A-Za-z0-9._-' '-')"
+MOCK_PORT="${MOCK_PORT:-$((PORT + 10000))}"
+
+if [ -n "$PLUGIN" ]; then
+  [ "$SEED_SET" = 1 ] || SEED="$PLUGIN"
+  PLUGINS_DIR="$(cd "$PLUGINS_DIR" && pwd)" || die "No atomic-plugins checkout at $PLUGINS_DIR"
+  [ -f "$PLUGINS_DIR/integrations/$PLUGIN/app/build.mjs" ] ||
+    die "No drive app at $PLUGINS_DIR/integrations/$PLUGIN/app/build.mjs"
+  [ -e "$PLUGINS_DIR/browser/package.json" ] ||
+    die "$PLUGINS_DIR has no browser/ linked. Run: (cd $PLUGINS_DIR && node integrations/tooling/link-atomic-server.mjs)"
+fi
+
+[ "$BUILD_ONLY" = 1 ] || for port in "$PORT" "$VITE_PORT" ${PLUGIN:+"$MOCK_PORT"}; do
+  if lsof -nP -tiTCP:"$port" -sTCP:LISTEN >/dev/null 2>&1; then
+    die "Port $port is in use (pid $(lsof -nP -tiTCP:"$port" -sTCP:LISTEN | head -1)). Pick another with --port/--vite-port."
+  fi
+done
+
+# --- Worktree for the branch -------------------------------------------------
+
+worktree_for() {
+  git -C "$REPO_ROOT" worktree list --porcelain |
+    awk -v ref="refs/heads/$1" '/^worktree /{wt=$2} $0=="branch "ref{print wt; exit}'
+}
+
+WORKTREE="$(worktree_for "$BRANCH")"
+
+if [ -z "$WORKTREE" ] && [[ "$BRANCH" =~ ^[0-9a-f]{7,40}$ ]]; then
+  # A commit (e.g. atomic-plugins' .atomic-server-ref): a detached worktree,
+  # so a moving branch head can't change what is tested.
+  git -C "$REPO_ROOT" fetch -q origin
+  SHA="$(git -C "$REPO_ROOT" rev-parse --verify "$BRANCH^{commit}")"
+  SLUG="${SHA:0:12}"
+  WORKTREE="$DEMO_HOME/worktrees/$SLUG"
+  if [ ! -d "$WORKTREE" ]; then
+    log "Creating a detached worktree for $SHA at $WORKTREE"
+    git -C "$REPO_ROOT" worktree add --detach "$WORKTREE" "$SHA"
+  fi
+fi
+
+if [ -z "$WORKTREE" ]; then
+  WORKTREE="$DEMO_HOME/worktrees/$SLUG"
+  log "Creating a worktree for $BRANCH at $WORKTREE"
+  git -C "$REPO_ROOT" fetch -q origin
+  if git -C "$REPO_ROOT" show-ref -q --verify "refs/heads/$BRANCH"; then
+    git -C "$REPO_ROOT" worktree add "$WORKTREE" "$BRANCH"
+  else
+    git -C "$REPO_ROOT" worktree add --no-track -b "$BRANCH" "$WORKTREE" "origin/$BRANCH"
+  fi
+fi
+
+log "Testing $BRANCH @ $(git -C "$WORKTREE" rev-parse --short HEAD) in $WORKTREE"
+[ -z "$(git -C "$WORKTREE" status --porcelain)" ] ||
+  log "Note: the worktree has uncommitted changes; they are included."
+
+BROWSER="$WORKTREE/browser"
+DATA_BROWSER="$BROWSER/data-browser"
+
+# --- Build ---------------------------------------------------------------------
+
+# True when any file under the given dirs is newer than the stamp file.
+newer_than() {
+  local stamp="$1"; shift
+  [ ! -f "$stamp" ] && return 0
+  [ -n "$(find "$@" -newer "$stamp" -type f -print -quit 2>/dev/null)" ]
+}
+
+build() {
+  mkdir -p "$DEMO_HOME/stamps"
+  local stamps="$DEMO_HOME/stamps/$SLUG"
+  mkdir -p "$stamps"
+
+  if newer_than "$stamps/pnpm-install" "$BROWSER/pnpm-lock.yaml" || [ ! -d "$BROWSER/node_modules" ]; then
+    log "pnpm install"
+    (cd "$BROWSER" && pnpm install --frozen-lockfile) && touch "$stamps/pnpm-install"
+  fi
+
+  # The workspace packages the data-browser imports from their built dist/.
+  local pkgs=(lib react edit-mode plugin service-ui) dirs=() filters=()
+  for pkg in "${pkgs[@]}"; do
+    dirs+=("$BROWSER/$pkg/src")
+    filters+=(--filter "@tomic/$pkg")
+  done
+  if newer_than "$stamps/js-libs" "${dirs[@]}"; then
+    log "Building ${pkgs[*]}"
+    (cd "$BROWSER" && pnpm "${filters[@]}" run build) && touch "$stamps/js-libs"
+  fi
+
+  # The wasm pair only depends on wasm/ and lib/; cache it by their git trees
+  # so switching branches does not rebuild it (about 3 minutes) needlessly.
+  local key dirty=""
+  key="$(git -C "$WORKTREE" rev-parse HEAD:wasm HEAD:lib | shasum | cut -c1-16)"
+  [ -z "$(git -C "$WORKTREE" status --porcelain -- wasm lib)" ] || dirty=1
+  local cache="$DEMO_HOME/wasm/$key"
+  if [ -n "$dirty" ] || [ ! -f "$cache/atomic_wasm_bg.wasm" ]; then
+    log "Building the wasm pair (wasm-pack)"
+    (cd "$WORKTREE/wasm" &&
+      CARGO_TARGET_DIR="$DEMO_HOME/target-wasm" env -u CARGO_ENCODED_RUSTFLAGS -u RUSTFLAGS \
+        cargo bin wasm-pack build --target web --out-dir pkg)
+    mkdir -p "$cache"
+    cp "$WORKTREE/wasm/pkg/atomic_wasm.js" "$WORKTREE/wasm/pkg/atomic_wasm_bg.wasm" "$cache/"
+  fi
+  mkdir -p "$DATA_BROWSER/public/wasm"
+  cp "$cache/atomic_wasm.js" "$cache/atomic_wasm_bg.wasm" "$DATA_BROWSER/public/wasm/"
+
+  # The server embeds a built frontend, but in a session the app comes from
+  # Vite; a placeholder page saves a full production build.
+  if [ ! -f "$WORKTREE/server/assets_tmp/index.html" ]; then
+    mkdir -p "$WORKTREE/server/assets_tmp"
+    printf '<!doctype html><title>atomic-server</title><p>Demo build: the app is served by the Vite dev server. See scripts/demo-session.</p>\n' \
+      >"$WORKTREE/server/assets_tmp/index.html"
+  fi
+
+  log "cargo build -p atomic-server (target: $DEMO_HOME/target)"
+  (cd "$WORKTREE" && SKIP_WASM_BUILD=1 ATOMICSERVER_SKIP_JS_BUILD=true \
+    CARGO_TARGET_DIR="$DEMO_HOME/target" cargo build -p atomic-server)
+}
+
+[ "$BUILD" = 1 ] && build
+[ "$BUILD_ONLY" = 1 ] && { log "Built $BRANCH."; exit 0; }
+
+# --- Session dir ----------------------------------------------------------------
+
+SESSION="$DEMO_HOME/sessions/$(date +%Y%m%d-%H%M%S)-$SLUG"
+mkdir -p "$SESSION/data" "$SESSION/config" "$SESSION/cache"
+# Freeze the binary: another branch's build may overwrite the shared target.
+cp "$DEMO_HOME/target/debug/atomic-server" "$SESSION/atomic-server"
+UX_LOG="$SESSION/ux.jsonl"
+touch "$UX_LOG"
+ln -sfn "$SESSION" "$DEMO_HOME/sessions/latest"
+
+cat >"$SESSION/session.env" <<EOF
+BRANCH=$BRANCH
+COMMIT=$(git -C "$WORKTREE" rev-parse HEAD)
+WORKTREE=$WORKTREE
+SERVER_URL=http://localhost:$PORT
+APP_URL=http://localhost:$VITE_PORT
+UX_LOG=$UX_LOG
+EOF
+
+# --- Drive app and mock integration proxy (--plugin) --------------------------
+
+PLUGIN_APP=""
+if [ -n "$PLUGIN" ]; then
+  PLUGIN_APP="$SESSION/plugin-app.js"
+  log "Building $PLUGIN's drive app from $PLUGINS_DIR ($(git -C "$PLUGINS_DIR" rev-parse --abbrev-ref HEAD) @ $(git -C "$PLUGINS_DIR" rev-parse --short HEAD))"
+  [ -d "$PLUGINS_DIR/integrations/$PLUGIN/app/node_modules" ] ||
+    (cd "$PLUGINS_DIR/integrations/$PLUGIN/app" && pnpm install --frozen-lockfile)
+  (cd "$PLUGINS_DIR" && node "integrations/$PLUGIN/app/build.mjs" --outfile "$PLUGIN_APP")
+  {
+    echo "PLUGIN=$PLUGIN"
+    echo "PLUGINS_DIR=$PLUGINS_DIR"
+    echo "PLUGINS_COMMIT=$(git -C "$PLUGINS_DIR" rev-parse HEAD)"
+    echo "PLUGIN_APP=$PLUGIN_APP"
+    echo "MOCK_PROXY_URL=http://127.0.0.1:$MOCK_PORT"
+    echo "MOCK_SCENARIO=$MOCK_SCENARIO"
+  } >>"$SESSION/session.env"
+fi
+
+PIDS=()
+cleanup() {
+  log "Stopping"
+  for pid in "${PIDS[@]}"; do kill "$pid" 2>/dev/null || true; done
+  wait 2>/dev/null || true
+  log "Session files kept in $SESSION"
+}
+trap cleanup EXIT INT TERM
+
+# --- atomic-server ----------------------------------------------------------------
+
+log "Starting atomic-server on http://localhost:$PORT (log: $SESSION/server.log)"
+ATOMIC_DATA_DIR="$SESSION/data" \
+ATOMIC_CONFIG_DIR="$SESSION/config" \
+ATOMIC_CACHE_DIR="$SESSION/cache" \
+ATOMIC_PORT="$PORT" \
+ATOMIC_DOMAIN=localhost \
+  env ${PLUGIN:+"ATOMIC_INTEGRATION_PROXY_URL=http://127.0.0.1:$MOCK_PORT"} \
+  ${PLUGIN:+"ATOMIC_INTEGRATION_FRONTEND_ORIGIN=http://localhost:$VITE_PORT"} \
+  "$SESSION/atomic-server" >"$SESSION/server.log" 2>&1 &
+PIDS+=($!)
+SERVER_PID=$!
+
+if [ -n "$PLUGIN" ]; then
+  # As integrations/tooling/serve.mjs starts it, except that the page is
+  # served by Vite here, so that is the origin /connect redirects back to.
+  log "Starting the mock integration proxy on http://127.0.0.1:$MOCK_PORT, scenario $MOCK_SCENARIO (log: $SESSION/mock-proxy.log)"
+  (
+    cd "$PLUGINS_DIR"
+    MOCK_PROXY_PORT="$MOCK_PORT" \
+    MOCK_PROXY_BASE_URL="http://127.0.0.1:$MOCK_PORT" \
+    MOCK_FRONTEND_ORIGIN="http://localhost:$VITE_PORT" \
+    MOCK_SCENARIO="$MOCK_SCENARIO" \
+      exec node integrations/localthought/mock-proxy.mjs
+  ) >"$SESSION/mock-proxy.log" 2>&1 &
+  PIDS+=($!)
+  for _ in $(seq 60); do
+    curl -sf -o /dev/null "http://127.0.0.1:$MOCK_PORT/catalog" && break
+    sleep 0.5
+  done
+  curl -sf -o /dev/null "http://127.0.0.1:$MOCK_PORT/catalog" || die "The mock proxy did not come up. See $SESSION/mock-proxy.log"
+fi
+
+for _ in $(seq 120); do
+  curl -sf -o /dev/null "http://localhost:$PORT/" && break
+  kill -0 "$SERVER_PID" 2>/dev/null || die "atomic-server exited. See $SESSION/server.log"
+  sleep 0.5
+done
+curl -sf -o /dev/null "http://localhost:$PORT/" || die "atomic-server did not come up. See $SESSION/server.log"
+
+# --- Vite -------------------------------------------------------------------------
+
+# The wrapper config is generated next to the data-browser (in its ignored
+# node_modules) so Vite's default config bundler can follow static imports of
+# both the branch's own vite.config.ts and this checkout's logger plugin.
+VITE_CONFIG="$DATA_BROWSER/node_modules/.demo-session/vite.config.ts"
+mkdir -p "$(dirname "$VITE_CONFIG")"
+cat >"$VITE_CONFIG" <<EOF
+// Generated by $TOOLING/demo-session.sh; do not edit.
+import base from '../../vite.config';
+import { uxLogPlugin } from '$TOOLING/uxLogPlugin';
+
+export default async (env: { command: string; mode: string }) => {
+  const config = typeof base === 'function' ? await base(env) : base;
+
+  return {
+    ...config,
+    root: '$DATA_BROWSER',
+    plugins: [
+      ...(config.plugins ?? []),
+      process.env.VITE_UX_LOG === 'true' &&
+        uxLogPlugin({
+          logFile: '$UX_LOG',
+          seedFile: '$TOOLING/seed.js',
+          clientFile: '$TOOLING/uxLogClient.js',
+          pluginAppFile: '$PLUGIN_APP' || undefined,
+        }),
+    ],
+    server: {
+      ...config.server,
+      port: $VITE_PORT,
+      strictPort: true,
+      host: 'localhost',
+      open: false,
+    },
+  };
+};
+EOF
+
+log "Starting the data-browser on http://localhost:$VITE_PORT (log: $SESSION/vite.log)"
+(
+  cd "$DATA_BROWSER"
+  node scripts/build-website-runtime.mjs
+  VITE_ATOMIC_SERVER_URL="http://localhost:$PORT" \
+  VITE_UX_LOG=true \
+    exec env ${PLUGIN:+"VITE_INTEGRATION_PROXY_URL=http://127.0.0.1:$MOCK_PORT"} \
+    node_modules/.bin/vite --config "$VITE_CONFIG"
+) >"$SESSION/vite.log" 2>&1 &
+PIDS+=($!)
+VITE_PID=$!
+
+for _ in $(seq 120); do
+  curl -sf -o /dev/null "http://localhost:$VITE_PORT/" && break
+  kill -0 "$VITE_PID" 2>/dev/null || die "Vite exited. See $SESSION/vite.log"
+  sleep 0.5
+done
+curl -sf -o /dev/null "http://localhost:$VITE_PORT/" || die "Vite did not come up. See $SESSION/vite.log"
+
+OPEN="http://localhost:$VITE_PORT/app/dev-drive"
+[ "$SEED" != none ] && OPEN="$OPEN?demo-seed=$SEED"
+echo "OPEN_URL=$OPEN" >>"$SESSION/session.env"
+
+log "Ready."
+log "  Open:        $OPEN"
+log "               (makes a fresh agent + drive in the browser, seeds '$SEED', opens it)"
+log "  Interaction: tail -f $UX_LOG"
+log "  Server:      tail -f $SESSION/server.log"
+[ -z "$PLUGIN" ] || {
+  log "  Mock proxy:  tail -f $SESSION/mock-proxy.log"
+  log "  Rebuild app: (cd $PLUGINS_DIR && node integrations/$PLUGIN/app/build.mjs --outfile $PLUGIN_APP)"
+  log "  Drivers:     curl -X POST http://127.0.0.1:$MOCK_PORT/fixture/<platform>/<driver> -d '[...]'"
+}
+log "Ctrl-C to stop."
+wait
diff --git a/scripts/demo-session/seed.js b/scripts/demo-session/seed.js
new file mode 100644
index 0000000000..b53af41b0a
--- /dev/null
+++ b/scripts/demo-session/seed.js
@@ -0,0 +1,314 @@
+// Demo seeds, run inside the page (see uxLogClient.js `__demoSeed`). Loaded as
+// a Vite virtual module, so imports resolve like the data-browser's own and
+// everything is created through the app's normal creation paths.
+//
+// Plain JS on purpose: virtual modules skip the TS transform.
+import { core, commits, Datatype } from '@tomic/react';
+import { buildTableFromSpec } from '@chunks/TablePage/createTableFromSpec';
+import { createPropertyOnClass } from '@chunks/TablePage/Kanban/createSelectProperty';
+import { addToOntology } from '@chunks/Demo/demoWorkspace';
+import { constructOpenURL } from '@helpers/navigation';
+
+const SEEDS = { calendar: seedCalendar, 'issue-tracker': seedIssueTracker };
+
+export async function seed(store, name, drive) {
+  const run = SEEDS[name];
+  if (!run)
+    throw new Error(`Unknown seed "${name}"; known: ${Object.keys(SEEDS)}`);
+
+  return run(store, drive);
+}
+
+const CALENDAR_ID = 'team@demo.example';
+const AMS = 'Europe/Amsterdam';
+const NYC = 'America/New_York';
+
+/** Rows of the "Team calendar" table. `recurrence` rows carry a
+ * Google-Calendar-shaped event, the format the calendar view expands.
+ *
+ * Keep `notes` to what a real user would write. Explanations of an edge case
+ * go in code comments: a note like "01:30 Wednesday in Amsterdam" answered a
+ * session task outright. */
+const TEAM_EVENTS = [
+  // --- Recurring (the view expands these) ---
+  {
+    name: 'Team standup',
+    day: '2026-09-07',
+    // Mon/Wed/Fri 09:30–09:45 Amsterdam until 18 Dec; 9 Oct skipped.
+    event: {
+      id: 'standup',
+      summary: 'Team standup',
+      start: { dateTime: '2026-09-07T09:30:00+02:00', timeZone: AMS },
+      end: { dateTime: '2026-09-07T09:45:00+02:00', timeZone: AMS },
+      recurrence: [
+        'RRULE:FREQ=WEEKLY;BYDAY=MO,WE,FR;UNTIL=20261218T235959Z',
+        `EXDATE;TZID=${AMS}:20261009T093000`,
+      ],
+    },
+  },
+  {
+    // One instance of the standup moved from Wed 14 Oct to Thu 15 Oct;
+    // nothing in the data tells the user so.
+    name: 'Team standup',
+    day: '2026-10-15',
+    event: {
+      id: 'standup_20261014T073000Z',
+      summary: 'Team standup',
+      recurringEventId: 'standup',
+      originalStartTime: { dateTime: '2026-10-14T09:30:00+02:00', timeZone: AMS },
+      start: { dateTime: '2026-10-15T10:00:00+02:00', timeZone: AMS },
+      end: { dateTime: '2026-10-15T10:15:00+02:00', timeZone: AMS },
+    },
+  },
+  {
+    name: 'Sprint review',
+    day: '2026-09-10',
+    // Every other Thursday 15:00, six times.
+    event: {
+      id: 'sprint-review',
+      summary: 'Sprint review',
+      start: { dateTime: '2026-09-10T15:00:00+02:00', timeZone: AMS },
+      end: { dateTime: '2026-09-10T16:00:00+02:00', timeZone: AMS },
+      recurrence: ['RRULE:FREQ=WEEKLY;INTERVAL=2;BYDAY=TH;COUNT=6'],
+    },
+  },
+  {
+    name: '1:1 with manager',
+    day: '2026-09-01',
+    // First Tuesday of the month, 11:00.
+    event: {
+      id: 'one-on-one',
+      summary: '1:1 with manager',
+      start: { dateTime: '2026-09-01T11:00:00+02:00', timeZone: AMS },
+      end: { dateTime: '2026-09-01T11:30:00+02:00', timeZone: AMS },
+      recurrence: ['RRULE:FREQ=MONTHLY;BYDAY=1TU'],
+    },
+  },
+  {
+    name: 'Late sync with Boston',
+    day: '2026-09-15',
+    // Tuesdays 19:30 New York = 01:30 Wednesday in Amsterdam; ten times.
+    event: {
+      id: 'boston-sync',
+      summary: 'Late sync with Boston',
+      start: { dateTime: '2026-09-15T19:30:00-04:00', timeZone: NYC },
+      end: { dateTime: '2026-09-15T20:30:00-04:00', timeZone: NYC },
+      recurrence: ['RRULE:FREQ=WEEKLY;BYDAY=TU;COUNT=10'],
+    },
+  },
+  {
+    name: 'Payday',
+    day: '2026-01-25',
+    allDay: true,
+    endDay: '2026-01-26',
+    event: {
+      id: 'payday',
+      summary: 'Payday',
+      start: { date: '2026-01-25' },
+      end: { date: '2026-01-26' },
+      recurrence: ['RRULE:FREQ=MONTHLY;BYMONTHDAY=25'],
+    },
+  },
+  {
+    name: 'Quarterly planning',
+    day: '2026-07-06',
+    allDay: true,
+    endDay: '2026-07-08',
+    // Two days from the first Monday of every third month.
+    event: {
+      id: 'quarterly-planning',
+      summary: 'Quarterly planning',
+      start: { date: '2026-07-06' },
+      end: { date: '2026-07-08' },
+      recurrence: ['RRULE:FREQ=MONTHLY;INTERVAL=3;BYDAY=1MO'],
+    },
+  },
+  {
+    name: "Mila's birthday",
+    day: '2019-10-03',
+    allDay: true,
+    endDay: '2019-10-04',
+    event: {
+      id: 'mila-birthday',
+      summary: "Mila's birthday",
+      start: { date: '2019-10-03' },
+      end: { date: '2019-10-04' },
+      recurrence: ['RRULE:FREQ=YEARLY'],
+    },
+  },
+
+  // --- Single events ---
+  { name: 'Invoice due', day: '2026-09-25' },
+  { name: 'Dentist', day: '2026-09-28', notes: '14:00' },
+  { name: 'Release 0.41', day: '2026-10-01' },
+  {
+    name: 'Offsite in Ghent',
+    day: '2026-10-06',
+    allDay: true,
+    endDay: '2026-10-09',
+    notes: 'Bring laptops',
+    // Tuesday to Thursday; End day is exclusive.
+  },
+  {
+    name: 'Clocks go back',
+    day: '2026-10-25',
+    allDay: true,
+    endDay: '2026-10-26',
+    // Europe leaves summer time; New York follows on 1 November.
+  },
+  {
+    name: 'Autumn holiday',
+    day: '2026-10-29',
+    allDay: true,
+    endDay: '2026-11-03',
+    // Thursday 29 Oct to Monday 2 Nov, across the month boundary.
+  },
+  {
+    name: 'Office closed',
+    day: '2026-11-11',
+    allDay: true,
+    // All day, but without an end day.
+  },
+  { name: 'Conference talk', day: '2027-01-15' },
+  // No date: only reachable from the table view.
+  { name: 'Plan the retro' },
+];
+
+const CONTENT_PLAN = [
+  { name: 'Launch post: calendar view', Channel: 'Blog', 'Publish date': '2026-09-29', Status: 'Scheduled' },
+  { name: 'October newsletter', Channel: 'Newsletter', 'Publish date': '2026-10-01', Status: 'Draft' },
+  { name: 'Teaser thread', Channel: 'Social', 'Publish date': '2026-09-25', Status: 'Published' },
+  { name: 'Case study: Ghent offsite', Channel: 'Blog', 'Publish date': '2026-10-13', Status: 'Draft' },
+  { name: 'Recap video', Channel: 'Social', 'Publish date': '2026-10-13', Status: 'Draft' },
+  { name: 'November newsletter', Channel: 'Newsletter', 'Publish date': '2026-11-03', Status: 'Draft' },
+  { name: 'Year in review', Channel: 'Blog', 'Publish date': '2026-12-21', Status: 'Draft' },
+  { name: 'Guest post idea', Channel: 'Blog', Status: 'Draft' },
+];
+
+async function seedCalendar(store, drive) {
+  const opts = {
+    parent: drive,
+    driveSubject: drive,
+    addToOntology: resource => addToOntology(store, drive, resource),
+  };
+
+  // --- Team calendar ---
+  const team = await buildTableFromSpec(
+    store,
+    {
+      name: 'Team calendar',
+      rowName: 'Event',
+      columns: [
+        { name: 'Day', type: 'date' },
+        { name: 'All day', type: 'checkbox' },
+        { name: 'End day', type: 'date' },
+        { name: 'Notes', type: 'text' },
+      ],
+      views: [
+        { name: 'Calendar', kind: 'calendar', groupByColumn: 'Day', default: true },
+        { name: 'All events', kind: 'table', sortByColumn: 'Day' },
+      ],
+    },
+    opts,
+  );
+
+  // The calendar view only reads all-day ranges and recurrence from these
+  // shortnames (matchesCalendarField in @tomic/lib calendar-date.ts).
+  const shortnames = {
+    Day: 'atomic-calendar-day',
+    'All day': 'atomic-calendar-all-day',
+    'End day': 'atomic-calendar-end-day',
+    Notes: 'atomic-calendar-notes',
+  };
+
+  for (const [column, shortname] of Object.entries(shortnames)) {
+    const property = await store.getResource(team.columns[column]);
+    await property.set(core.properties.shortname, shortname);
+    await property.save();
+  }
+
+  const rowClass = await store.getResource(team.classSubject);
+  const recurrence = await createPropertyOnClass(store, rowClass, {
+    name: 'Recurrence',
+    datatype: Datatype.JSON,
+    description: 'The Google-Calendar-shaped event the calendar view expands.',
+    propVals: { [core.properties.shortname]: 'atomic-calendar-recurrence' },
+  });
+
+  let created = Date.now() - TEAM_EVENTS.length * 1000;
+
+  for (const row of TEAM_EVENTS) {
+    const propVals = {
+      [core.properties.name]: row.name,
+      [commits.properties.createdAt]: created++,
+    };
+    if (row.day) propVals[team.columns.Day] = row.day;
+    if (row.allDay) propVals[team.columns['All day']] = true;
+    if (row.endDay) propVals[team.columns['End day']] = row.endDay;
+    if (row.notes) propVals[team.columns.Notes] = row.notes;
+    if (row.event)
+      propVals[recurrence] = { calendarId: CALENDAR_ID, event: row.event };
+
+    const resource = await store.newResource({
+      parent: team.tableSubject,
+      isA: team.classSubject,
+      propVals,
+    });
+    await resource.save();
+  }
+
+  // --- Content plan: has a date column, but no calendar view yet ---
+  const content = await buildTableFromSpec(
+    store,
+    {
+      name: 'Content plan',
+      rowName: 'Piece',
+      columns: [
+        { name: 'Channel', type: 'select', options: ['Blog', 'Newsletter', 'Social'] },
+        { name: 'Publish date', type: 'date' },
+        { name: 'Status', type: 'select', options: ['Draft', 'Scheduled', 'Published'] },
+      ],
+      views: [{ name: 'All pieces', kind: 'table', default: true }],
+      rows: CONTENT_PLAN,
+    },
+    opts,
+  );
+
+  return {
+    teamCalendar: team.tableSubject,
+    contentPlan: content.tableSubject,
+    open: constructOpenURL(team.tableSubject),
+  };
+}
+
+/**
+ * The GitHub issues drive app from atomic-plugins, installed the way the
+ * "New app" template makes an app (`createApp`, then `handOverAppKey`), with
+ * the source demo-session.sh built (`--plugin issue-tracker`) instead of the
+ * starter. Its data comes from the mock integration proxy's github-issues
+ * fixture, not from this seed; the tester connects and picks the repository
+ * in the app. Imported lazily: branches without drive apps still load the
+ * calendar seed.
+ */
+async function seedIssueTracker(store, drive) {
+  return installPluginApp(store, drive, { name: 'GitHub issues', emoji: '🐞' });
+}
+
+async function installPluginApp(store, drive, { name, emoji }) {
+  const response = await fetch('/__demo-plugin/app.js');
+  if (!response.ok)
+    throw new Error(
+      `No plugin app to install (HTTP ${response.status}); start demo-session.sh with --plugin`,
+    );
+  const source = await response.text();
+  const { createApp } = await import('@tomic/lib');
+  const { handOverAppKey } = await import('@chunks/AppPage/appAgent');
+  const created = await createApp(store, { drive, name, emoji, source });
+  await handOverAppKey(store, {
+    drive,
+    app: created.app,
+    secret: created.secret,
+  });
+
+  return { app: created.app, open: constructOpenURL(created.app) };
+}
diff --git a/scripts/demo-session/uxLogClient.js b/scripts/demo-session/uxLogClient.js
new file mode 100644
index 0000000000..d0529ef7fc
--- /dev/null
+++ b/scripts/demo-session/uxLogClient.js
@@ -0,0 +1,469 @@
+// In-page half of the dev-only interaction logger (see uxLogPlugin.ts).
+// Records what a test user does and what goes wrong, and posts it to the Vite
+// dev server, which appends it to a JSONL file the session observer tails.
+//
+// Logged: clicks (text, role, test id, short selector, and for table cells
+// the row and column), committed input values
+// (80 characters at most; password fields and anything labelled secret, key,
+// token or password are never logged), Enter/Escape, route changes, dialogs
+// and toasts appearing, console.error/warn, uncaught errors, failed or slow
+// fetches, and WebSocket closes that were not clean.
+//
+// Also exposes `window.__demoSeed(name)` and runs it once when the page was
+// opened with `?demo-seed=<name>` (normally on /app/dev-drive).
+
+const ENDPOINT = '/__ux-log';
+const MAX_TEXT = 80;
+const SLOW_FETCH_MS = 3000;
+const SECRET_HINT = /password|secret|token|api.?key|private/i;
+const originalFetch = window.fetch.bind(window);
+
+let queue = [];
+let flushTimer;
+
+function now() {
+  return new Date().toISOString();
+}
+
+function clip(value) {
+  const text = String(value ?? '')
+    .replace(/\s+/g, ' ')
+    .trim();
+
+  return text.length > MAX_TEXT ? text.slice(0, MAX_TEXT) + '…' : text;
+}
+
+function log(type, data) {
+  queue.push({ t: now(), type, path: location.pathname, ...data });
+  clearTimeout(flushTimer);
+  flushTimer = setTimeout(flush, 300);
+}
+
+function flush() {
+  if (!queue.length) return;
+  const body = JSON.stringify(queue);
+  queue = [];
+  originalFetch(ENDPOINT, {
+    method: 'POST',
+    body,
+    keepalive: true,
+    headers: { 'content-type': 'application/json' },
+  }).catch(() => undefined);
+}
+
+window.addEventListener('pagehide', flush);
+
+// --- Element description -----------------------------------------------------
+
+const INTERACTIVE =
+  'button,a,input,select,textarea,label,summary,[role],[data-testid],[contenteditable="true"],[tabindex]';
+
+function shortSelector(el) {
+  const parts = [];
+  let node = el;
+
+  while (node && node.nodeType === 1 && parts.length < 4) {
+    let part = node.tagName.toLowerCase();
+    const testId = node.getAttribute('data-testid');
+    if (node.id && !/^[:r]/.test(node.id)) part += `#${node.id}`;
+    if (testId) part += `[data-testid="${testId}"]`;
+    parts.unshift(part);
+    if (testId || node.id) break;
+    node = node.parentElement;
+  }
+
+  return parts.join(' > ');
+}
+
+function labelFor(el) {
+  return clip(
+    el.getAttribute('aria-label') ||
+      el.getAttribute('title') ||
+      (el.labels && el.labels[0]?.innerText) ||
+      el.getAttribute('placeholder') ||
+      el.getAttribute('name') ||
+      '',
+  );
+}
+
+function isSecretField(el) {
+  return (
+    el.type === 'password' ||
+    SECRET_HINT.test(
+      [
+        el.name,
+        el.id,
+        el.getAttribute('autocomplete'),
+        el.getAttribute('placeholder'),
+        labelFor(el),
+      ].join(' '),
+    )
+  );
+}
+
+// A table-editor cell has no text of its own worth logging (often empty, or
+// an input); name it by its row's first column and its column header.
+function tableCell(el) {
+  const cell = el.closest?.('[role="gridcell"],[role="rowheader"]');
+  if (!cell) return undefined;
+  const row = cell.closest('[role="row"]');
+  const grid = cell.closest('[role="grid"]');
+  const colIndex = cell.getAttribute('aria-colindex');
+  const header =
+    colIndex &&
+    grid?.querySelector(`[role="columnheader"][aria-colindex="${colIndex}"]`);
+
+  return {
+    row:
+      clip(row?.querySelector('[aria-colindex="2"]')?.innerText) || undefined,
+    column: clip(header?.innerText) || undefined,
+    rowIndex: row?.getAttribute('aria-rowindex') ?? undefined,
+  };
+}
+
+function describe(target) {
+  const el = target.closest?.(INTERACTIVE) ?? target;
+  const within = el.closest?.('[data-testid]');
+  const dialog = el.closest?.('[role="dialog"],dialog');
+
+  return {
+    cell: tableCell(el),
+    text: isSecretField(el) ? '[redacted]' : clip(el.innerText || el.value),
+    label: labelFor(el) || undefined,
+    role: el.getAttribute?.('role') || el.tagName?.toLowerCase(),
+    testid: el.getAttribute?.('data-testid') || undefined,
+    within:
+      within && within !== el ? within.getAttribute('data-testid') : undefined,
+    dialog: dialog ? clip(dialogTitle(dialog)) || true : undefined,
+    date: el.closest?.('[data-date]')?.getAttribute('data-date') || undefined,
+    sel: shortSelector(el),
+  };
+}
+
+function dialogTitle(dialog) {
+  const heading = dialog.querySelector('h1,h2,h3,[role="heading"]');
+
+  return (
+    dialog.getAttribute('aria-label') ||
+    heading?.innerText ||
+    dialog.innerText?.slice(0, 40)
+  );
+}
+
+// --- User actions ------------------------------------------------------------
+
+document.addEventListener(
+  'click',
+  e => log('click', describe(e.target)),
+  true,
+);
+
+document.addEventListener(
+  'change',
+  e => {
+    const el = e.target;
+    if (!(el instanceof HTMLElement)) return;
+    const secret = isSecretField(el);
+    log('input', {
+      label: labelFor(el),
+      cell: tableCell(el),
+      value: secret
+        ? '[redacted]'
+        : el.type === 'checkbox'
+          ? el.checked
+          : clip(el.value),
+      sel: shortSelector(el),
+    });
+  },
+  true,
+);
+
+document.addEventListener(
+  'keydown',
+  e => {
+    if (e.key !== 'Enter' && e.key !== 'Escape') return;
+    const el = e.target;
+    const value =
+      el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement
+        ? isSecretField(el)
+          ? '[redacted]'
+          : clip(el.value)
+        : el.isContentEditable
+          ? clip(el.innerText)
+          : undefined;
+    log('key', { key: e.key, value, sel: shortSelector(el) });
+  },
+  true,
+);
+
+// --- Navigation --------------------------------------------------------------
+
+let lastUrl = location.pathname + location.search;
+
+function routeChanged(how) {
+  const url = location.pathname + location.search;
+  if (url === lastUrl) return;
+  log('route', { how, from: lastUrl, to: url });
+  lastUrl = url;
+}
+
+for (const method of ['pushState', 'replaceState']) {
+  const original = history[method];
+  history[method] = function (...args) {
+    const result = original.apply(this, args);
+    routeChanged(method);
+
+    return result;
+  };
+}
+
+window.addEventListener('popstate', () => routeChanged('popstate'));
+
+// --- Dialogs and toasts appearing --------------------------------------------
+
+const seen = new WeakSet();
+
+function isVisible(el) {
+  if (el.tagName === 'DIALOG' && !el.open) return false;
+
+  return el.checkVisibility
+    ? el.checkVisibility({ opacityProperty: true, visibilityProperty: true })
+    : el.offsetParent !== null;
+}
+
+new MutationObserver(records => {
+  for (const record of records) {
+    // A native <dialog> opened in place with showModal().
+    if (record.type === 'attributes') {
+      const el = record.target;
+      if (el.tagName === 'DIALOG' && el.open)
+        setTimeout(() => log('dialog', { title: clip(dialogTitle(el)) }), 300);
+      continue;
+    }
+
+    for (const node of record.addedNodes) {
+      if (!(node instanceof HTMLElement)) continue;
+      const found = [
+        node,
+        ...node.querySelectorAll('[role="dialog"],dialog[open],[role="status"],[role="alert"]'),
+      ];
+
+      for (const el of found) {
+        if (seen.has(el)) continue;
+        const role = el.getAttribute('role') || el.tagName.toLowerCase();
+
+        if (role !== 'dialog' && role !== 'status' && role !== 'alert')
+          continue;
+        // The app keeps some dialogs and live regions mounted but hidden;
+        // only log what the user can actually see.
+        setTimeout(() => {
+          if (seen.has(el) || !isVisible(el)) return;
+          seen.add(el);
+          if (role === 'dialog') {
+            log('dialog', { title: clip(dialogTitle(el)) });
+          } else {
+            const text = clip(el.innerText);
+            if (text) log('toast', { role, text });
+          }
+        }, 300);
+      }
+    }
+  }
+}).observe(document.documentElement, {
+  childList: true,
+  subtree: true,
+  attributes: true,
+  attributeFilter: ['open'],
+});
+
+// --- Errors ------------------------------------------------------------------
+
+function stringify(arg) {
+  if (arg instanceof Error) return `${arg.name}: ${arg.message}`;
+  if (typeof arg === 'string') return arg;
+  try {
+    return JSON.stringify(arg);
+  } catch {
+    return String(arg);
+  }
+}
+
+for (const level of ['error', 'warn']) {
+  const original = console[level];
+  console[level] = function (...args) {
+    try {
+      log(`console-${level}`, {
+        message: args.map(stringify).join(' ').slice(0, 500),
+      });
+    } catch {
+      // Never let the logger break the app.
+    }
+
+    return original.apply(this, args);
+  };
+}
+
+window.addEventListener('error', e =>
+  log('uncaught', {
+    message: String(e.message).slice(0, 500),
+    source: e.filename ? `${e.filename}:${e.lineno}:${e.colno}` : undefined,
+  }),
+);
+
+// Scripts, styles and images that fail to load: `error` does not bubble for
+// these, so listen in the capture phase.
+window.addEventListener(
+  'error',
+  e => {
+    const el = e.target;
+    if (!(el instanceof HTMLElement)) return;
+    log('resource-failed', {
+      tag: el.tagName.toLowerCase(),
+      url: shortUrl(el.src || el.href || ''),
+    });
+  },
+  true,
+);
+
+// Vite's own error overlay (a failed import or transform).
+if (import.meta.hot) {
+  import.meta.hot.on('vite:error', payload =>
+    log('vite-error', {
+      message: String(payload?.err?.message ?? '').slice(0, 500),
+      file: payload?.err?.id,
+    }),
+  );
+}
+
+window.addEventListener('unhandledrejection', e =>
+  log('unhandled-rejection', { message: stringify(e.reason).slice(0, 500) }),
+);
+
+// --- Network -----------------------------------------------------------------
+
+function shortUrl(input) {
+  const url = typeof input === 'string' ? input : (input?.url ?? String(input));
+
+  return url.length > 200 ? url.slice(0, 200) + '…' : url;
+}
+
+window.fetch = async function (input, init) {
+  const started = performance.now();
+  const method = (init?.method || input?.method || 'GET').toUpperCase();
+
+  try {
+    const response = await originalFetch(input, init);
+    const ms = Math.round(performance.now() - started);
+
+    if (!response.ok) {
+      let body;
+      try {
+        body = clip(await response.clone().text());
+      } catch {
+        body = undefined;
+      }
+      log('fetch-failed', {
+        method,
+        url: shortUrl(input),
+        status: response.status,
+        ms,
+        body,
+      });
+    } else if (ms > SLOW_FETCH_MS) {
+      log('fetch-slow', { method, url: shortUrl(input), ms });
+    }
+
+    return response;
+  } catch (error) {
+    if (error?.name !== 'AbortError')
+      log('fetch-error', {
+        method,
+        url: shortUrl(input),
+        message: stringify(error),
+      });
+    throw error;
+  }
+};
+
+const OriginalWebSocket = window.WebSocket;
+window.WebSocket = class extends OriginalWebSocket {
+  constructor(...args) {
+    super(...args);
+    this.addEventListener('close', e => {
+      if (e.code !== 1000 && e.code !== 1001)
+        log('ws-close', { url: shortUrl(args[0]), code: e.code, reason: e.reason });
+    });
+  }
+};
+
+// --- Seeding -----------------------------------------------------------------
+
+async function waitFor(check, what, timeoutMs = 60000) {
+  const start = Date.now();
+
+  while (Date.now() - start < timeoutMs) {
+    const value = check();
+    if (value) return value;
+    await new Promise(resolve => setTimeout(resolve, 250));
+  }
+
+  throw new Error(`Timed out waiting for ${what}`);
+}
+
+window.__demoSeed = async name => {
+  const store = await waitFor(() => window.store?.getAgent() && window.store, 'a signed-in store');
+  const drive = await waitFor(() => store.getDrive(), 'a drive');
+  const { seed } = await import('virtual:demo-seed');
+  log('seed-start', { name, drive });
+  const result = await seed(store, name, drive);
+  log('seed-done', { name, ...result });
+
+  return result;
+};
+
+// `?demo-seed=<name>` on /app/dev-drive: that route creates an agent and a
+// drive, navigates to the drive, and the app may then reload the page. The
+// request is kept in sessionStorage so the seed runs once, on whichever page
+// load settles on the new drive, and never twice.
+const PENDING_KEY = 'demo-session.pending-seed';
+
+function sessionGet(key) {
+  try {
+    return sessionStorage.getItem(key);
+  } catch {
+    return null;
+  }
+}
+
+function sessionSet(key, value) {
+  try {
+    if (value === null) sessionStorage.removeItem(key);
+    else sessionStorage.setItem(key, value);
+  } catch {
+    // Seeding is a convenience; without storage it just does not run.
+  }
+}
+
+const requestedSeed = new URLSearchParams(location.search).get('demo-seed');
+if (requestedSeed) sessionSet(PENDING_KEY, requestedSeed);
+
+if (sessionGet(PENDING_KEY)) {
+  (async () => {
+    await waitFor(
+      () =>
+        !location.pathname.startsWith('/app/dev-drive') &&
+        window.store?.getAgent() &&
+        window.store.getDrive(),
+      'the dev drive',
+    );
+    // Give a post-sign-in reload the chance to happen first.
+    await new Promise(resolve => setTimeout(resolve, 3000));
+    const name = sessionGet(PENDING_KEY);
+    if (!name) return;
+    sessionSet(PENDING_KEY, null);
+    const result = await window.__demoSeed(name);
+    if (result?.open) location.assign(result.open);
+  })().catch(error => log('seed-failed', { message: stringify(error) }));
+}
+
+log('page-load', { url: location.pathname + location.search, ua: navigator.userAgent.slice(0, 120) });
diff --git a/scripts/demo-session/uxLogPlugin.ts b/scripts/demo-session/uxLogPlugin.ts
new file mode 100644
index 0000000000..02aa8d20b6
--- /dev/null
+++ b/scripts/demo-session/uxLogPlugin.ts
@@ -0,0 +1,115 @@
+// Dev-only Vite plugin for live user-testing sessions: an interaction logger
+// and an in-page seed step. See scripts/demo-session/README.md.
+//
+// `apply: 'serve'` keeps it out of every `vite build`, and it is only added by
+// the config demo-session.sh generates, when VITE_UX_LOG=true, so no
+// production bundle can contain it. It does not import from `vite`, because it
+// lives outside the data-browser package and its node_modules.
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+const CLIENT_ID = 'virtual:ux-log-client';
+const SEED_ID = 'virtual:demo-seed';
+const ENDPOINT = '/__ux-log';
+const PLUGIN_APP = '/__demo-plugin/app.js';
+
+interface Options {
+  /** JSONL file that every event is appended to. */
+  logFile: string;
+  /** Seed module (plain JS, `export async function seed(store, name)`). */
+  seedFile: string;
+  /** The in-page logger (plain JS). */
+  clientFile: string;
+  /**
+   * A built drive app module, served at /__demo-plugin/app.js for the seed
+   * that installs it. Read on every request, so a rebuild needs no restart.
+   */
+  pluginAppFile?: string;
+}
+
+// Minimal structural types, so this file needs no `vite` import.
+interface Req {
+  method?: string;
+  url?: string;
+  on(event: 'data', cb: (chunk: Buffer) => void): void;
+  on(event: 'end', cb: () => void): void;
+}
+interface Res {
+  statusCode: number;
+  setHeader(name: string, value: string): void;
+  end(body?: string): void;
+}
+interface DevServer {
+  middlewares: {
+    use(fn: (req: Req, res: Res, next: () => void) => void): void;
+  };
+}
+
+export function uxLogPlugin({
+  logFile,
+  seedFile,
+  clientFile,
+  pluginAppFile,
+}: Options) {
+  fs.mkdirSync(path.dirname(logFile), { recursive: true });
+
+  const append = (entries: unknown[]) => {
+    const lines = entries.map(e => JSON.stringify(e)).join('\n');
+    if (lines) fs.appendFileSync(logFile, lines + '\n');
+  };
+
+  append([{ t: new Date().toISOString(), type: 'vite-start' }]);
+
+  return {
+    name: 'demo-ux-log',
+    apply: 'serve' as const,
+    resolveId(id: string) {
+      if (id === CLIENT_ID || id === SEED_ID) return '\0' + id;
+
+      return undefined;
+    },
+    load(id: string) {
+      if (id === '\0' + CLIENT_ID) return fs.readFileSync(clientFile, 'utf-8');
+      if (id === '\0' + SEED_ID) return fs.readFileSync(seedFile, 'utf-8');
+
+      return undefined;
+    },
+    transformIndexHtml(html: string) {
+      return html.replace(
+        '</head>',
+        `<script type="module" src="/@id/__x00__${CLIENT_ID}"></script></head>`,
+      );
+    },
+    configureServer(server: DevServer) {
+      server.middlewares.use((req, res, next) => {
+        if (req.url === PLUGIN_APP && req.method === 'GET') {
+          if (!pluginAppFile || !fs.existsSync(pluginAppFile)) {
+            res.statusCode = 404;
+            res.end();
+
+            return;
+          }
+          res.setHeader('Content-Type', 'text/javascript; charset=utf-8');
+          res.setHeader('Cache-Control', 'no-store');
+          res.end(fs.readFileSync(pluginAppFile, 'utf-8'));
+
+          return;
+        }
+
+        if (req.url !== ENDPOINT || req.method !== 'POST') return next();
+        let body = '';
+        req.on('data', chunk => (body += chunk.toString()));
+        req.on('end', () => {
+          try {
+            const parsed = JSON.parse(body);
+            append(Array.isArray(parsed) ? parsed : [parsed]);
+            res.statusCode = 204;
+          } catch {
+            res.statusCode = 400;
+          }
+          res.end();
+        });
+      });
+    },
+  };
+}