diff --git a/dogfood/20260424-libghostty-vt-renderer/README.md b/dogfood/20260424-libghostty-vt-renderer/README.md
new file mode 100644
index 0000000..4a1be0e
--- /dev/null
+++ b/dogfood/20260424-libghostty-vt-renderer/README.md
@@ -0,0 +1,55 @@
+# Phase 6 libghostty-vt renderer proof bundle
+
+This bundle captures a focused Phase 6 dogfood run for commit `efee65e` (`feat(renderer): add selectable libghostty-vt backend`). It demonstrates the new global `--renderer libghostty-vt` flag end-to-end against the `hello-prompt` fixture, with a `--renderer ghostty-web` baseline captured from the same terminal interaction.
+
+## What this proves
+
+- The native addon is installed and importable: `native-info.json` is the raw output from `@coder/libghostty-vt-node`'s `getNativeInfo()` and reports package `0.1.0-beta.0` on linux/x64.
+- `ghostty-web` remains a working baseline renderer: `ghostty-web-wait.json`, `ghostty-web-snapshot.json`, `ghostty-web-screenshot.json`, and `screenshots/ghostty-web.png` were produced with `--renderer ghostty-web`.
+- `libghostty-vt` is selectable for semantic renderer operations: `libghostty-vt-wait.json` and `libghostty-vt-snapshot.json` were produced with `--renderer libghostty-vt` after driving the fixture with `type` + `send-keys`.
+- PNG screenshot fallback is honest about its producer: `libghostty-vt-screenshot.json` was requested with `--renderer libghostty-vt`, and its `result.rendererBackend` is `ghostty-web`. The copied PNG is `screenshots/libghostty-vt-fallback.png`.
+- WebM export fallback is also honest about its producer: `libghostty-vt-record-webm.json` was requested with `--renderer libghostty-vt`, and its `result.metadata.rendererBackend` is `ghostty-web`. The copied video is `videos/libghostty-vt-fallback.webm`.
+- The terminal recording remains available as asciicast: `libghostty-vt-record-cast.json` exports `recordings/terminal-session.cast`.
+- `inspect.json` was captured near the end of the native session after clean fixture exit and export. It shows a clean-exit session with healthy snapshot, screenshot, recording, and video artifacts. Because the process had already exited, `inspect` uses offline replay and reports the replay fallback runtime; the semantic renderer proof is in the `--renderer libghostty-vt` wait/snapshot commands and envelopes.
+
+The two PNGs are byte-identical in this capture. `commands.sh` enforces that with `cmp -s` after copying both screenshots.
+
+## Bundle contents
+
+- `commands.sh` — self-contained replay script. It creates an isolated `AGENT_TTY_HOME` with `mktemp -d -t agent-tty-dogfood.XXXXXX`, runs the repo-local CLI via `npx tsx src/cli/main.ts`, captures all envelopes/artifacts, and cleans up the temporary home.
+- `environment.txt` — Node/npm versions, git HEAD, OS details, the requested root `--version` probe, supported `version --json` output, and native-addon metadata.
+- `native-info.json` — raw native addon metadata from `getNativeInfo()`.
+- `ghostty-web-*.json` — baseline wait, snapshot, and screenshot envelopes.
+- `libghostty-vt-*.json` — native-run wait, snapshot, screenshot, asciicast export, and WebM export envelopes.
+- `inspect.json` — final native session inspection envelope.
+- `screenshots/ghostty-web.png` — baseline ghostty-web PNG.
+- `screenshots/libghostty-vt-fallback.png` — PNG requested under `--renderer libghostty-vt` and produced by the ghostty-web fallback path.
+- `recordings/terminal-session.cast` — asciicast export for the native run. The current CLI schema names the format `asciicast`; the artifact uses the conventional `.cast` extension.
+- `videos/libghostty-vt-fallback.webm` — WebM export requested under `--renderer libghostty-vt` and produced by the ghostty-web fallback path.
+
+## How to reproduce
+
+From the repository root:
+
+```bash
+bash dogfood/20260424-libghostty-vt-renderer/commands.sh
+```
+
+The script requires `jq`, `node`, `npm`, `npx`, and the already-installed project dependencies. It does not write to `~/.agent-tty`; every CLI invocation uses the temporary `AGENT_TTY_HOME` created at script startup.
+
+## Reviewer checks
+
+```bash
+find dogfood/20260424-libghostty-vt-renderer -type f | sort
+jq '.ok' dogfood/20260424-libghostty-vt-renderer/*.json
+jq -r '.result.rendererBackend' dogfood/20260424-libghostty-vt-renderer/libghostty-vt-screenshot.json
+jq -r '.result.metadata.rendererBackend' dogfood/20260424-libghostty-vt-renderer/libghostty-vt-record-webm.json
+file dogfood/20260424-libghostty-vt-renderer/screenshots/*.png
+file dogfood/20260424-libghostty-vt-renderer/videos/*.webm
+file dogfood/20260424-libghostty-vt-renderer/recordings/*.cast
+cmp -s \
+  dogfood/20260424-libghostty-vt-renderer/screenshots/ghostty-web.png \
+  dogfood/20260424-libghostty-vt-renderer/screenshots/libghostty-vt-fallback.png
+```
+
+`jq '.ok'` prints `true` for every CLI envelope. It prints `null` once for `native-info.json` because that file is intentionally the raw native-addon info object, not a CLI envelope.
diff --git a/dogfood/20260424-libghostty-vt-renderer/commands.sh b/dogfood/20260424-libghostty-vt-renderer/commands.sh
new file mode 100755
index 0000000..7d6ec3e
--- /dev/null
+++ b/dogfood/20260424-libghostty-vt-renderer/commands.sh
@@ -0,0 +1,264 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_ROOT="$(git -C "$SCRIPT_DIR" rev-parse --show-toplevel)"
+BUNDLE_DIR="$SCRIPT_DIR"
+SCREENSHOTS_DIR="$BUNDLE_DIR/screenshots"
+RECORDINGS_DIR="$BUNDLE_DIR/recordings"
+VIDEOS_DIR="$BUNDLE_DIR/videos"
+CLI=(npx tsx src/cli/main.ts)
+CLI_WITH_TIMEOUT=(npx tsx src/cli/main.ts --timeout-ms 120000)
+FIXTURE=(npx tsx test/fixtures/apps/hello-prompt/main.ts)
+PROMPT_TEXT='READY>'
+ECHO_TEXT='Phase 6 renderer proof'
+AGENT_TTY_HOME="$(mktemp -d -t agent-tty-dogfood.XXXXXX)"
+export AGENT_TTY_HOME
+GHOSTTY_WEB_SESSION_ID=''
+LIBGHOSTTY_VT_SESSION_ID=''
+
+require_command() {
+  command -v "$1" >/dev/null 2>&1 || {
+    printf 'missing required command: %s\n' "$1" >&2
+    exit 1
+  }
+}
+
+assert_file_nonempty() {
+  local path="$1"
+  [[ -s "$path" ]] || {
+    printf 'expected non-empty file: %s\n' "$path" >&2
+    exit 1
+  }
+}
+
+run_json_file() {
+  local output_path="$1"
+  shift
+  local tmp_path="$output_path.tmp"
+  "$@" > "$tmp_path"
+  jq . "$tmp_path" > "$output_path"
+  rm -f "$tmp_path"
+  jq -e '.ok == true' "$output_path" >/dev/null
+}
+
+capture_json_var() {
+  local __resultvar="$1"
+  shift
+  local raw_json
+  local pretty_json
+  raw_json="$($@)"
+  pretty_json="$(printf '%s\n' "$raw_json" | jq .)"
+  printf '%s\n' "$pretty_json" | jq -e '.ok == true' >/dev/null
+  printf -v "$__resultvar" '%s' "$pretty_json"
+}
+
+run_json_check_only() {
+  "$@" | jq -e '.ok == true' >/dev/null
+}
+
+cleanup() {
+  local exit_code=$?
+  set +e
+  if [[ -n "${GHOSTTY_WEB_SESSION_ID:-}" ]]; then
+    "${CLI_WITH_TIMEOUT[@]}" --home "$AGENT_TTY_HOME" destroy "$GHOSTTY_WEB_SESSION_ID" --json >/dev/null 2>&1 || true
+  fi
+  if [[ -n "${LIBGHOSTTY_VT_SESSION_ID:-}" ]]; then
+    "${CLI_WITH_TIMEOUT[@]}" --home "$AGENT_TTY_HOME" destroy "$LIBGHOSTTY_VT_SESSION_ID" --json >/dev/null 2>&1 || true
+  fi
+  if [[ -n "${AGENT_TTY_HOME:-}" && -d "${AGENT_TTY_HOME:-}" ]]; then
+    rm -rf "$AGENT_TTY_HOME"
+  fi
+  exit "$exit_code"
+}
+trap cleanup EXIT
+
+require_command git
+require_command jq
+require_command node
+require_command npm
+require_command npx
+require_command uname
+
+mkdir -p "$SCREENSHOTS_DIR" "$RECORDINGS_DIR" "$VIDEOS_DIR"
+rm -f "$BUNDLE_DIR"/*.json "$BUNDLE_DIR/environment.txt"
+rm -f "$SCREENSHOTS_DIR"/*.png "$RECORDINGS_DIR"/*.cast "$VIDEOS_DIR"/*.webm
+
+cd "$REPO_ROOT"
+
+# Capture native addon metadata before any renderer run. Import failure means the
+# optional libghostty-vt dependency is unavailable in this workspace.
+node --input-type=module > "$BUNDLE_DIR/native-info.json" <<'NODE'
+const { getNativeInfo } = await import('@coder/libghostty-vt-node');
+console.log(JSON.stringify(getNativeInfo(), null, 2));
+NODE
+jq -e '.packageVersion and .ghosttyVersion and .platform and .arch' "$BUNDLE_DIR/native-info.json" >/dev/null
+
+# Capture environment details without secrets. The root --version form is
+# included because it was requested for this proof bundle; this CLI currently
+# exposes the machine-readable version through `version --json`.
+{
+  printf '$ node --version\n%s\n\n' "$(node --version)"
+  printf '$ npm --version\n%s\n\n' "$(npm --version)"
+  printf '$ git rev-parse HEAD\n%s\n\n' "$(git rev-parse HEAD)"
+  printf '$ git log --oneline -n 1\n%s\n\n' "$(git log --oneline -n 1)"
+  printf '$ uname -a\n%s\n\n' "$(uname -a)"
+  printf '$ npx tsx src/cli/main.ts --version\n'
+  if version_output="$("${CLI[@]}" --version 2>&1)"; then
+    printf '%s\n\n' "$version_output"
+  else
+    printf '%s\n' "$version_output"
+    printf '(command exited non-zero; use `npx tsx src/cli/main.ts version --json` for this CLI)\n\n'
+  fi
+  printf '$ npx tsx src/cli/main.ts version --json\n'
+  "${CLI[@]}" version --json | jq .
+  printf '\n$ node --input-type=module -e "import getNativeInfo"\n'
+  cat "$BUNDLE_DIR/native-info.json"
+} > "$BUNDLE_DIR/environment.txt"
+
+# Sanity check the isolated home before starting proof sessions. This is not
+# retained as a bundle artifact because the reviewer-facing proof is the two
+# renderer runs below.
+"${CLI_WITH_TIMEOUT[@]}" --home "$AGENT_TTY_HOME" doctor --json | jq -e '.ok == true and .result.ok == true' >/dev/null
+
+# Ghostty-web baseline: run the hello-prompt fixture, drive the same short input
+# as the native run, then capture wait/snapshot/screenshot envelopes.
+GHOSTTY_CREATE_JSON=''
+capture_json_var \
+  GHOSTTY_CREATE_JSON \
+  "${CLI_WITH_TIMEOUT[@]}" --home "$AGENT_TTY_HOME" --renderer ghostty-web \
+  create --json --cwd "$REPO_ROOT" --cols 80 --rows 24 --name phase6-ghostty-web -- "${FIXTURE[@]}"
+GHOSTTY_WEB_SESSION_ID="$(printf '%s\n' "$GHOSTTY_CREATE_JSON" | jq -er '.result.sessionId')"
+run_json_check_only \
+  "${CLI_WITH_TIMEOUT[@]}" --home "$AGENT_TTY_HOME" --renderer ghostty-web \
+  wait "$GHOSTTY_WEB_SESSION_ID" --json --text "$PROMPT_TEXT" --timeout 10000
+run_json_check_only \
+  "${CLI_WITH_TIMEOUT[@]}" --home "$AGENT_TTY_HOME" --renderer ghostty-web \
+  type "$GHOSTTY_WEB_SESSION_ID" --json "$ECHO_TEXT"
+run_json_check_only \
+  "${CLI_WITH_TIMEOUT[@]}" --home "$AGENT_TTY_HOME" --renderer ghostty-web \
+  send-keys "$GHOSTTY_WEB_SESSION_ID" --json Enter
+run_json_file \
+  "$BUNDLE_DIR/ghostty-web-wait.json" \
+  "${CLI_WITH_TIMEOUT[@]}" --home "$AGENT_TTY_HOME" --renderer ghostty-web \
+  wait "$GHOSTTY_WEB_SESSION_ID" --json --text "ECHO: $ECHO_TEXT" --timeout 10000
+run_json_check_only \
+  "${CLI_WITH_TIMEOUT[@]}" --home "$AGENT_TTY_HOME" --renderer ghostty-web \
+  wait "$GHOSTTY_WEB_SESSION_ID" --json --screen-stable-ms 250 --timeout 10000
+run_json_file \
+  "$BUNDLE_DIR/ghostty-web-snapshot.json" \
+  "${CLI_WITH_TIMEOUT[@]}" --home "$AGENT_TTY_HOME" --renderer ghostty-web \
+  snapshot "$GHOSTTY_WEB_SESSION_ID" --format text --json
+run_json_file \
+  "$BUNDLE_DIR/ghostty-web-screenshot.json" \
+  "${CLI_WITH_TIMEOUT[@]}" --home "$AGENT_TTY_HOME" --renderer ghostty-web \
+  screenshot "$GHOSTTY_WEB_SESSION_ID" --hide-cursor --json
+GHOSTTY_SCREENSHOT_SOURCE="$(jq -er '.result.artifactPath' "$BUNDLE_DIR/ghostty-web-screenshot.json")"
+assert_file_nonempty "$GHOSTTY_SCREENSHOT_SOURCE"
+cp "$GHOSTTY_SCREENSHOT_SOURCE" "$SCREENSHOTS_DIR/ghostty-web.png"
+assert_file_nonempty "$SCREENSHOTS_DIR/ghostty-web.png"
+jq -e '.result.rendererBackend == "ghostty-web"' "$BUNDLE_DIR/ghostty-web-screenshot.json" >/dev/null
+run_json_check_only \
+  "${CLI_WITH_TIMEOUT[@]}" --home "$AGENT_TTY_HOME" \
+  destroy "$GHOSTTY_WEB_SESSION_ID" --json
+GHOSTTY_WEB_SESSION_ID=''
+
+# Libghostty-vt run: semantic wait/snapshot use the selected native backend;
+# screenshot and WebM are intentionally produced by the ghostty-web fallback.
+LIB_CREATE_JSON=''
+capture_json_var \
+  LIB_CREATE_JSON \
+  "${CLI_WITH_TIMEOUT[@]}" --home "$AGENT_TTY_HOME" --renderer libghostty-vt \
+  create --json --cwd "$REPO_ROOT" --cols 80 --rows 24 --name phase6-libghostty-vt -- "${FIXTURE[@]}"
+LIBGHOSTTY_VT_SESSION_ID="$(printf '%s\n' "$LIB_CREATE_JSON" | jq -er '.result.sessionId')"
+run_json_check_only \
+  "${CLI_WITH_TIMEOUT[@]}" --home "$AGENT_TTY_HOME" --renderer libghostty-vt \
+  wait "$LIBGHOSTTY_VT_SESSION_ID" --json --text "$PROMPT_TEXT" --timeout 10000
+run_json_check_only \
+  "${CLI_WITH_TIMEOUT[@]}" --home "$AGENT_TTY_HOME" --renderer libghostty-vt \
+  type "$LIBGHOSTTY_VT_SESSION_ID" --json "$ECHO_TEXT"
+run_json_check_only \
+  "${CLI_WITH_TIMEOUT[@]}" --home "$AGENT_TTY_HOME" --renderer libghostty-vt \
+  send-keys "$LIBGHOSTTY_VT_SESSION_ID" --json Enter
+run_json_file \
+  "$BUNDLE_DIR/libghostty-vt-wait.json" \
+  "${CLI_WITH_TIMEOUT[@]}" --home "$AGENT_TTY_HOME" --renderer libghostty-vt \
+  wait "$LIBGHOSTTY_VT_SESSION_ID" --json --text "ECHO: $ECHO_TEXT" --timeout 10000
+run_json_check_only \
+  "${CLI_WITH_TIMEOUT[@]}" --home "$AGENT_TTY_HOME" --renderer libghostty-vt \
+  wait "$LIBGHOSTTY_VT_SESSION_ID" --json --screen-stable-ms 250 --timeout 10000
+run_json_file \
+  "$BUNDLE_DIR/libghostty-vt-snapshot.json" \
+  "${CLI_WITH_TIMEOUT[@]}" --home "$AGENT_TTY_HOME" --renderer libghostty-vt \
+  snapshot "$LIBGHOSTTY_VT_SESSION_ID" --format text --json
+run_json_file \
+  "$BUNDLE_DIR/libghostty-vt-screenshot.json" \
+  "${CLI_WITH_TIMEOUT[@]}" --home "$AGENT_TTY_HOME" --renderer libghostty-vt \
+  screenshot "$LIBGHOSTTY_VT_SESSION_ID" --hide-cursor --json
+LIB_SCREENSHOT_SOURCE="$(jq -er '.result.artifactPath' "$BUNDLE_DIR/libghostty-vt-screenshot.json")"
+assert_file_nonempty "$LIB_SCREENSHOT_SOURCE"
+cp "$LIB_SCREENSHOT_SOURCE" "$SCREENSHOTS_DIR/libghostty-vt-fallback.png"
+assert_file_nonempty "$SCREENSHOTS_DIR/libghostty-vt-fallback.png"
+jq -e '.result.rendererBackend == "ghostty-web"' "$BUNDLE_DIR/libghostty-vt-screenshot.json" >/dev/null
+
+# End the fixture cleanly, then export both recording formats from the native run.
+run_json_check_only \
+  "${CLI_WITH_TIMEOUT[@]}" --home "$AGENT_TTY_HOME" --renderer libghostty-vt \
+  type "$LIBGHOSTTY_VT_SESSION_ID" --json 'exit'
+run_json_check_only \
+  "${CLI_WITH_TIMEOUT[@]}" --home "$AGENT_TTY_HOME" --renderer libghostty-vt \
+  send-keys "$LIBGHOSTTY_VT_SESSION_ID" --json Enter
+run_json_check_only \
+  "${CLI_WITH_TIMEOUT[@]}" --home "$AGENT_TTY_HOME" --renderer libghostty-vt \
+  wait "$LIBGHOSTTY_VT_SESSION_ID" --json --exit --timeout 10000
+run_json_file \
+  "$BUNDLE_DIR/libghostty-vt-record-cast.json" \
+  "${CLI_WITH_TIMEOUT[@]}" --home "$AGENT_TTY_HOME" --renderer libghostty-vt \
+  record export "$LIBGHOSTTY_VT_SESSION_ID" --format asciicast --json
+CAST_SOURCE="$(jq -er '.result.artifactPath' "$BUNDLE_DIR/libghostty-vt-record-cast.json")"
+assert_file_nonempty "$CAST_SOURCE"
+cp "$CAST_SOURCE" "$RECORDINGS_DIR/terminal-session.cast"
+run_json_file \
+  "$BUNDLE_DIR/libghostty-vt-record-webm.json" \
+  "${CLI_WITH_TIMEOUT[@]}" --home "$AGENT_TTY_HOME" --renderer libghostty-vt \
+  record export "$LIBGHOSTTY_VT_SESSION_ID" --format webm --json
+WEBM_SOURCE="$(jq -er '.result.artifactPath' "$BUNDLE_DIR/libghostty-vt-record-webm.json")"
+assert_file_nonempty "$WEBM_SOURCE"
+cp "$WEBM_SOURCE" "$VIDEOS_DIR/libghostty-vt-fallback.webm"
+assert_file_nonempty "$RECORDINGS_DIR/terminal-session.cast"
+assert_file_nonempty "$VIDEOS_DIR/libghostty-vt-fallback.webm"
+jq -e '.result.format == "asciicast"' "$BUNDLE_DIR/libghostty-vt-record-cast.json" >/dev/null
+jq -e '.result.metadata.rendererBackend == "ghostty-web"' "$BUNDLE_DIR/libghostty-vt-record-webm.json" >/dev/null
+node -e '
+const fs = require("node:fs");
+const lines = fs.readFileSync(process.argv[1], "utf8").trimEnd().split(/\r?\n/);
+if (lines.length === 0) throw new Error("empty asciicast");
+JSON.parse(lines[0]);
+for (const line of lines.slice(1)) JSON.parse(line);
+' "$RECORDINGS_DIR/terminal-session.cast"
+
+run_json_file \
+  "$BUNDLE_DIR/inspect.json" \
+  "${CLI_WITH_TIMEOUT[@]}" --home "$AGENT_TTY_HOME" --renderer libghostty-vt \
+  inspect "$LIBGHOSTTY_VT_SESSION_ID" --json
+run_json_check_only \
+  "${CLI_WITH_TIMEOUT[@]}" --home "$AGENT_TTY_HOME" \
+  destroy "$LIBGHOSTTY_VT_SESSION_ID" --json
+LIBGHOSTTY_VT_SESSION_ID=''
+
+# Both screenshots are generated by ghostty-web from identical terminal content.
+# A byte-for-byte comparison keeps this proof objective and reviewer-repeatable.
+cmp -s "$SCREENSHOTS_DIR/ghostty-web.png" "$SCREENSHOTS_DIR/libghostty-vt-fallback.png"
+
+# Top-level CLI envelopes should report ok=true. native-info.json is intentionally
+# not a CLI envelope, so it is excluded from this assertion.
+for json_file in "$BUNDLE_DIR"/*.json; do
+  if [[ "$(basename "$json_file")" == 'native-info.json' ]]; then
+    continue
+  fi
+  jq -e '.ok == true' "$json_file" >/dev/null
+done
+
+trap - EXIT
+rm -rf "$AGENT_TTY_HOME"
+unset AGENT_TTY_HOME
diff --git a/dogfood/20260424-libghostty-vt-renderer/environment.txt b/dogfood/20260424-libghostty-vt-renderer/environment.txt
new file mode 100644
index 0000000..1a1e651
--- /dev/null
+++ b/dogfood/20260424-libghostty-vt-renderer/environment.txt
@@ -0,0 +1,108 @@
+$ node --version
+v22.19.0
+
+$ npm --version
+10.9.3
+
+$ git rev-parse HEAD
+efee65ee798b41b1f176781f312fbbd0761a5af8
+
+$ git log --oneline -n 1
+efee65e feat(renderer): add selectable libghostty-vt backend
+
+$ uname -a
+Linux aaaaaaa 6.8.0-94-generic #96-Ubuntu SMP PREEMPT_DYNAMIC Fri Jan  9 20:36:55 UTC 2026 x86_64 x86_64 x86_64 GNU/Linux
+
+$ npx tsx src/cli/main.ts --version
+error: unknown option '--version'
+
+MANDATORY FOR CODING AGENTS: read the `agent-tty` skill first. If your agent already loaded that skill, follow it; otherwise run `agent-tty skills get agent-tty` before any other agent-tty command.
+
+
+Usage: agent-tty [options] [command]
+
+CLI for managing and controlling terminal sessions
+
+Options:
+  --home <path>                               Override the agent-tty home directory
+  --timeout-ms <n>                            Set a shared CLI timeout in milliseconds
+  --no-color                                  Disable ANSI color in human-readable output
+  --log-level <level>                         Set log level (debug, info, warn, error)
+  --profile <name>                            Default render profile name
+  --renderer <name>                           Renderer backend (ghostty-web or libghostty-vt)
+  -h, --help                                  display help for command
+
+Commands:
+  skills                                      Manage built-in skills
+  version [options]                           Print version
+  doctor [options]                            Check env
+  create [options] [command...]               Create a session
+  list [options]                              List sessions
+  inspect [options] <session-id>              Inspect a session
+  destroy [options] <session-id>              Destroy a session
+  gc [options]                                Clean up stale or exited sessions
+  type [options] <session-id> [text]          Type text into a session
+  paste [options] <session-id> [text]         Paste text into a session
+  run [options] <session-id> [command]        Run a command in a session and optionally wait for completion
+  mark [options] <session-id> <label>         Add a marker to a session
+  send-keys [options] <session-id> <keys...>  Send keys to a session
+  resize [options] <session-id>               Resize a session
+  signal [options] <session-id> <signal>      Send a signal to a session
+  snapshot [options] <session-id>             Capture a terminal snapshot
+  screenshot [options] <session-id>           Capture a rendered screenshot
+  record                                      Manage recorded session artifacts
+  wait [options] <session-id>                 Wait for a session condition
+  help [command]                              display help for command
+
+Coding agents: after loading the core `agent-tty` skill, run `agent-tty skills list` to discover other bundled skills and `agent-tty skills get <name>` to load one.
+(command exited non-zero; use `npx tsx src/cli/main.ts version --json` for this CLI)
+
+$ npx tsx src/cli/main.ts version --json
+{
+  "ok": true,
+  "command": "version",
+  "timestamp": "2026-04-24T19:31:29.498Z",
+  "result": {
+    "cliVersion": "0.1.1-beta.3",
+    "protocolVersion": "0.1.0",
+    "rendererBackends": [
+      "ghostty-web"
+    ],
+    "runtime": {
+      "node": "v25.9.0",
+      "platform": "linux",
+      "arch": "x64"
+    },
+    "capabilities": [
+      {
+        "name": "snapshot",
+        "status": "available"
+      },
+      {
+        "name": "wait",
+        "status": "available"
+      },
+      {
+        "name": "screenshot",
+        "status": "available"
+      },
+      {
+        "name": "record-export-asciicast",
+        "status": "available"
+      },
+      {
+        "name": "record-export-webm",
+        "status": "available"
+      }
+    ]
+  }
+}
+
+$ node --input-type=module -e "import getNativeInfo"
+{
+  "napiVersion": 10,
+  "ghosttyVersion": "0.1.0-dev",
+  "packageVersion": "0.1.0-beta.0",
+  "platform": "linux",
+  "arch": "x64"
+}
diff --git a/dogfood/20260424-libghostty-vt-renderer/ghostty-web-screenshot.json b/dogfood/20260424-libghostty-vt-renderer/ghostty-web-screenshot.json
new file mode 100644
index 0000000..85e4e39
--- /dev/null
+++ b/dogfood/20260424-libghostty-vt-renderer/ghostty-web-screenshot.json
@@ -0,0 +1,20 @@
+{
+  "ok": true,
+  "command": "screenshot",
+  "timestamp": "2026-04-24T19:31:42.372Z",
+  "result": {
+    "sessionId": "01KQ0FKNNZPCPCRVXX2TN6E774",
+    "capturedAtSeq": 6,
+    "profileName": "reference-dark",
+    "cols": 80,
+    "rows": 24,
+    "artifactPath": "/tmp/agent-tty-dogfood.b67EGa/sessions/01KQ0FKNNZPCPCRVXX2TN6E774/artifacts/screenshot-6-reference-dark.png",
+    "pngSizeBytes": 6129,
+    "cursorVisible": false,
+    "rendererBackend": "ghostty-web",
+    "pixelWidth": 640,
+    "pixelHeight": 384,
+    "sha256": "6dd4625cea7d858b8b5250e748761771d387dca92d64feb272eff97ab0cb556e",
+    "renderProfileHash": "8ffed6af301ec7c0e6b69599c3be0d1d12096f9fcdfc59d0bbb4cc474d64c53d"
+  }
+}
diff --git a/dogfood/20260424-libghostty-vt-renderer/ghostty-web-snapshot.json b/dogfood/20260424-libghostty-vt-renderer/ghostty-web-snapshot.json
new file mode 100644
index 0000000..7da9e5d
--- /dev/null
+++ b/dogfood/20260424-libghostty-vt-renderer/ghostty-web-snapshot.json
@@ -0,0 +1,15 @@
+{
+  "ok": true,
+  "command": "snapshot",
+  "timestamp": "2026-04-24T19:31:40.986Z",
+  "result": {
+    "format": "text",
+    "sessionId": "01KQ0FKNNZPCPCRVXX2TN6E774",
+    "capturedAtSeq": 6,
+    "cols": 80,
+    "rows": 24,
+    "cursorRow": 2,
+    "cursorCol": 7,
+    "text": "READY> Phase 6 renderer proof\nECHO: Phase 6 renderer proof\nREADY>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
+  }
+}
diff --git a/dogfood/20260424-libghostty-vt-renderer/ghostty-web-wait.json b/dogfood/20260424-libghostty-vt-renderer/ghostty-web-wait.json
new file mode 100644
index 0000000..ce120fc
--- /dev/null
+++ b/dogfood/20260424-libghostty-vt-renderer/ghostty-web-wait.json
@@ -0,0 +1,13 @@
+{
+  "ok": true,
+  "command": "wait",
+  "timestamp": "2026-04-24T19:31:38.044Z",
+  "result": {
+    "matched": true,
+    "timedOut": false,
+    "matchedText": "ECHO: Phase 6 renderer proof",
+    "cursorRow": 2,
+    "cursorCol": 7,
+    "capturedAtSeq": 6
+  }
+}
diff --git a/dogfood/20260424-libghostty-vt-renderer/inspect.json b/dogfood/20260424-libghostty-vt-renderer/inspect.json
new file mode 100644
index 0000000..cc90d8e
--- /dev/null
+++ b/dogfood/20260424-libghostty-vt-renderer/inspect.json
@@ -0,0 +1,49 @@
+{
+  "ok": true,
+  "command": "inspect",
+  "timestamp": "2026-04-24T19:32:03.987Z",
+  "result": {
+    "session": {
+      "version": 1,
+      "sessionId": "01KQ0FM1WQ5ETGBNSYK93G0H8T",
+      "createdAt": "2026-04-24T19:31:44.666Z",
+      "updatedAt": "2026-04-24T19:31:56.928Z",
+      "status": "exited",
+      "command": ["npx", "tsx", "test/fixtures/apps/hello-prompt/main.ts"],
+      "cwd": "/home/coder/.mux/src/agent-terminal/agent_exec_2d8f238d80",
+      "name": "phase6-libghostty-vt",
+      "shell": "/bin/bash",
+      "term": "xterm-256color",
+      "cols": 80,
+      "rows": 24,
+      "creationCols": 80,
+      "creationRows": 24,
+      "hostPid": 1338881,
+      "childPid": 1338894,
+      "exitCode": 0,
+      "exitSignal": null
+    },
+    "eventCount": 15,
+    "uptime": 12262,
+    "lastEventSeq": 14,
+    "terminationCategory": "clean-exit",
+    "artifacts": {
+      "total": 4,
+      "byKind": {
+        "snapshot": 1,
+        "screenshot": 1,
+        "recording": 1,
+        "video": 1
+      },
+      "missingCount": 0,
+      "health": "healthy"
+    },
+    "usedOfflineReplay": false,
+    "rendererRuntime": {
+      "backend": "ghostty-web",
+      "mode": "offline-replay",
+      "status": "fallback",
+      "reason": "session-not-running"
+    }
+  }
+}
diff --git a/dogfood/20260424-libghostty-vt-renderer/libghostty-vt-record-cast.json b/dogfood/20260424-libghostty-vt-renderer/libghostty-vt-record-cast.json
new file mode 100644
index 0000000..35b92b4
--- /dev/null
+++ b/dogfood/20260424-libghostty-vt-renderer/libghostty-vt-record-cast.json
@@ -0,0 +1,23 @@
+{
+  "ok": true,
+  "command": "record export",
+  "timestamp": "2026-04-24T19:31:59.169Z",
+  "result": {
+    "sessionId": "01KQ0FM1WQ5ETGBNSYK93G0H8T",
+    "format": "asciicast",
+    "artifactPath": "/tmp/agent-tty-dogfood.b67EGa/sessions/01KQ0FM1WQ5ETGBNSYK93G0H8T/artifacts/recording-14-asciicast.cast",
+    "bytes": 456,
+    "sha256": "8f8c8dd0548fa94917a3efc64b00982f830762f2275619b308332f1466a0661f",
+    "capturedAtSeq": 14,
+    "durationMs": 11141,
+    "metadata": {
+      "width": 80,
+      "height": 24,
+      "title": "01KQ0FM1WQ5ETGBNSYK93G0H8T",
+      "timestamp": 1777059105,
+      "outputEventCount": 10,
+      "resizeEventCount": 0,
+      "markerCount": 0
+    }
+  }
+}
diff --git a/dogfood/20260424-libghostty-vt-renderer/libghostty-vt-record-webm.json b/dogfood/20260424-libghostty-vt-renderer/libghostty-vt-record-webm.json
new file mode 100644
index 0000000..a72155e
--- /dev/null
+++ b/dogfood/20260424-libghostty-vt-renderer/libghostty-vt-record-webm.json
@@ -0,0 +1,24 @@
+{
+  "ok": true,
+  "command": "record export",
+  "timestamp": "2026-04-24T19:32:02.673Z",
+  "result": {
+    "sessionId": "01KQ0FM1WQ5ETGBNSYK93G0H8T",
+    "format": "webm",
+    "artifactPath": "/tmp/agent-tty-dogfood.b67EGa/sessions/01KQ0FM1WQ5ETGBNSYK93G0H8T/artifacts/recording-14-webm.webm",
+    "bytes": 20848,
+    "sha256": "66f15e14a348f3793e222922e407cfc453293b02045ccae9cb865b6bb4665902",
+    "capturedAtSeq": 14,
+    "durationMs": 11141,
+    "metadata": {
+      "width": 80,
+      "height": 24,
+      "profileName": "reference-dark",
+      "renderProfileHash": "8ffed6af301ec7c0e6b69599c3be0d1d12096f9fcdfc59d0bbb4cc474d64c53d",
+      "timingMode": "accelerated",
+      "rendererBackend": "ghostty-web",
+      "outputEventCount": 10,
+      "resizeEventCount": 0
+    }
+  }
+}
diff --git a/dogfood/20260424-libghostty-vt-renderer/libghostty-vt-screenshot.json b/dogfood/20260424-libghostty-vt-renderer/libghostty-vt-screenshot.json
new file mode 100644
index 0000000..fd26076
--- /dev/null
+++ b/dogfood/20260424-libghostty-vt-renderer/libghostty-vt-screenshot.json
@@ -0,0 +1,20 @@
+{
+  "ok": true,
+  "command": "screenshot",
+  "timestamp": "2026-04-24T19:31:54.632Z",
+  "result": {
+    "sessionId": "01KQ0FM1WQ5ETGBNSYK93G0H8T",
+    "capturedAtSeq": 5,
+    "profileName": "reference-dark",
+    "cols": 80,
+    "rows": 24,
+    "artifactPath": "/tmp/agent-tty-dogfood.b67EGa/sessions/01KQ0FM1WQ5ETGBNSYK93G0H8T/artifacts/screenshot-5-reference-dark.png",
+    "pngSizeBytes": 6129,
+    "cursorVisible": false,
+    "rendererBackend": "ghostty-web",
+    "pixelWidth": 640,
+    "pixelHeight": 384,
+    "sha256": "6dd4625cea7d858b8b5250e748761771d387dca92d64feb272eff97ab0cb556e",
+    "renderProfileHash": "8ffed6af301ec7c0e6b69599c3be0d1d12096f9fcdfc59d0bbb4cc474d64c53d"
+  }
+}
diff --git a/dogfood/20260424-libghostty-vt-renderer/libghostty-vt-snapshot.json b/dogfood/20260424-libghostty-vt-renderer/libghostty-vt-snapshot.json
new file mode 100644
index 0000000..98f3a8a
--- /dev/null
+++ b/dogfood/20260424-libghostty-vt-renderer/libghostty-vt-snapshot.json
@@ -0,0 +1,15 @@
+{
+  "ok": true,
+  "command": "snapshot",
+  "timestamp": "2026-04-24T19:31:53.152Z",
+  "result": {
+    "format": "text",
+    "sessionId": "01KQ0FM1WQ5ETGBNSYK93G0H8T",
+    "capturedAtSeq": 5,
+    "cols": 80,
+    "rows": 24,
+    "cursorRow": 2,
+    "cursorCol": 7,
+    "text": "READY> Phase 6 renderer proof\nECHO: Phase 6 renderer proof\nREADY>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
+  }
+}
diff --git a/dogfood/20260424-libghostty-vt-renderer/libghostty-vt-wait.json b/dogfood/20260424-libghostty-vt-renderer/libghostty-vt-wait.json
new file mode 100644
index 0000000..44a5e01
--- /dev/null
+++ b/dogfood/20260424-libghostty-vt-renderer/libghostty-vt-wait.json
@@ -0,0 +1,13 @@
+{
+  "ok": true,
+  "command": "wait",
+  "timestamp": "2026-04-24T19:31:50.261Z",
+  "result": {
+    "matched": true,
+    "timedOut": false,
+    "matchedText": "ECHO: Phase 6 renderer proof",
+    "cursorRow": 2,
+    "cursorCol": 7,
+    "capturedAtSeq": 5
+  }
+}
diff --git a/dogfood/20260424-libghostty-vt-renderer/native-info.json b/dogfood/20260424-libghostty-vt-renderer/native-info.json
new file mode 100644
index 0000000..48965ca
--- /dev/null
+++ b/dogfood/20260424-libghostty-vt-renderer/native-info.json
@@ -0,0 +1,7 @@
+{
+  "napiVersion": 10,
+  "ghosttyVersion": "0.1.0-dev",
+  "packageVersion": "0.1.0-beta.0",
+  "platform": "linux",
+  "arch": "x64"
+}
diff --git a/dogfood/20260424-libghostty-vt-renderer/recordings/terminal-session.cast b/dogfood/20260424-libghostty-vt-renderer/recordings/terminal-session.cast
new file mode 100644
index 0000000..327e829
--- /dev/null
+++ b/dogfood/20260424-libghostty-vt-renderer/recordings/terminal-session.cast
@@ -0,0 +1,11 @@
+{"version":2,"width":80,"height":24,"timestamp":1777059105,"title":"01KQ0FM1WQ5ETGBNSYK93G0H8T","sessionId":"01KQ0FM1WQ5ETGBNSYK93G0H8T","env":{"TERM":"xterm-256color"},"toolVersion":"0.1.1-beta.3"}
+[0,"o","READY> "]
+[2.176,"o","Phase 6 renderer proof"]
+[3.18,"o","\r\n"]
+[3.181,"o","ECHO: Phase 6 renderer proof\r\nREADY> "]
+[10.02,"o","exit"]
+[11.107,"o","\r\n"]
+[11.108,"o","BYE\r\n"]
+[11.126,"o","\\"]
+[11.129,"o","\u001b[1G"]
+[11.129,"o","\u001b[0K"]
diff --git a/dogfood/20260424-libghostty-vt-renderer/screenshots/ghostty-web.png b/dogfood/20260424-libghostty-vt-renderer/screenshots/ghostty-web.png
new file mode 100644
index 0000000..154e5a0
Binary files /dev/null and b/dogfood/20260424-libghostty-vt-renderer/screenshots/ghostty-web.png differ
diff --git a/dogfood/20260424-libghostty-vt-renderer/screenshots/libghostty-vt-fallback.png b/dogfood/20260424-libghostty-vt-renderer/screenshots/libghostty-vt-fallback.png
new file mode 100644
index 0000000..154e5a0
Binary files /dev/null and b/dogfood/20260424-libghostty-vt-renderer/screenshots/libghostty-vt-fallback.png differ
diff --git a/dogfood/20260424-libghostty-vt-renderer/videos/libghostty-vt-fallback.webm b/dogfood/20260424-libghostty-vt-renderer/videos/libghostty-vt-fallback.webm
new file mode 100644
index 0000000..1310fee
Binary files /dev/null and b/dogfood/20260424-libghostty-vt-renderer/videos/libghostty-vt-fallback.webm differ
diff --git a/package-lock.json b/package-lock.json
index ddb0148..417f173 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -33,6 +33,34 @@
       },
       "engines": {
         "node": ">=24.0.0 <26"
+      },
+      "optionalDependencies": {
+        "@coder/libghostty-vt-node": "0.1.0-beta.0"
+      }
+    },
+    "node_modules/@coder/libghostty-vt-node": {
+      "version": "0.1.0-beta.0",
+      "resolved": "https://registry.npmjs.org/@coder/libghostty-vt-node/-/libghostty-vt-node-0.1.0-beta.0.tgz",
+      "integrity": "sha512-m0KqgBfEzD7G6DIFWe3OSGoa0muDHneXDKHDVz8sJdSYl2N8HN9W642H3LSw2YDkw9VuxxkbHqXdN98akkqwxQ==",
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "node-addon-api": "^8.3.1",
+        "node-gyp-build": "^4.8.4"
+      },
+      "engines": {
+        "node": ">=20.19"
+      }
+    },
+    "node_modules/@coder/libghostty-vt-node/node_modules/node-addon-api": {
+      "version": "8.7.0",
+      "resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-8.7.0.tgz",
+      "integrity": "sha512-9MdFxmkKaOYVTV+XVRG8ArDwwQ77XIgIPyKASB1k3JPq3M8fGQQQE3YpMOrKm6g//Ktx8ivZr8xo1Qmtqub+GA==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": "^18 || ^20 || >= 21"
       }
     },
     "node_modules/@emnapi/core": {
@@ -2424,6 +2452,18 @@
       "integrity": "sha512-5m3bsyrjFWE1xf7nz7YXdN4udnVtXK6/Yfgn5qnahL6bCkf2yKt4k3nuTKAtT4r3IG8JNR2ncsIMdZuAzJjHQQ==",
       "license": "MIT"
     },
+    "node_modules/node-gyp-build": {
+      "version": "4.8.4",
+      "resolved": "https://registry.npmjs.org/node-gyp-build/-/node-gyp-build-4.8.4.tgz",
+      "integrity": "sha512-LA4ZjwlnUblHVgq0oBF3Jl/6h/Nvs5fzBLwdEF4nuxnFdsfajde4WfxtJr3CaiH+F6ewcIB/q4jQ4UzPyid+CQ==",
+      "license": "MIT",
+      "optional": true,
+      "bin": {
+        "node-gyp-build": "bin.js",
+        "node-gyp-build-optional": "optional.js",
+        "node-gyp-build-test": "build-test.js"
+      }
+    },
     "node_modules/node-pty": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/node-pty/-/node-pty-1.1.0.tgz",
diff --git a/package.json b/package.json
index 1d0582c..de43660 100644
--- a/package.json
+++ b/package.json
@@ -79,5 +79,8 @@
     "playwright": "1.58.2",
     "ulid": "3.0.2",
     "zod": "4.3.6"
+  },
+  "optionalDependencies": {
+    "@coder/libghostty-vt-node": "0.1.0-beta.0"
   }
 }
diff --git a/src/cli/commands/record-export.ts b/src/cli/commands/record-export.ts
index e80a16d..418cd83 100644
--- a/src/cli/commands/record-export.ts
+++ b/src/cli/commands/record-export.ts
@@ -15,7 +15,6 @@ import {
   type WebmExportResult,
 } from '../../export/webm.js';
 import { readEventLogRecords } from '../../host/replay.js';
-import { GhosttyWebBackend } from '../../renderer/ghosttyWeb/backend.js';
 import { hashProfile, resolveProfile } from '../../renderer/profiles.js';
 import { CliError } from '../errors.js';
 import { ERROR_CODES, makeCliError } from '../../protocol/errors.js';
@@ -313,23 +312,18 @@ export async function runRecordExportCommand(
       );
 
       invariant(events.length > 0, 'webm export requires at least one event');
-      const webmResult: WebmExportResult = await generateWebmExport(
-        {
-          sessionId: options.sessionId,
-          sessionDir: sessionDirectory,
-          manifest,
-          events,
-          outputPath: artifactOutputPath,
-          ...(webmProfileName !== undefined
-            ? { profileName: webmProfileName }
-            : {}),
-          ...(timingMode !== undefined ? { timingMode } : {}),
-        },
-        {
-          backendFactory: (sessionId, profile, videoOptions) =>
-            new GhosttyWebBackend(sessionId, profile, videoOptions),
-        },
-      );
+      const webmResult: WebmExportResult = await generateWebmExport({
+        sessionId: options.sessionId,
+        sessionDir: sessionDirectory,
+        manifest,
+        events,
+        outputPath: artifactOutputPath,
+        ...(webmProfileName !== undefined
+          ? { profileName: webmProfileName }
+          : {}),
+        ...(timingMode !== undefined ? { timingMode } : {}),
+        rendererName: options.context.rendererDefault,
+      });
 
       const resolvedProfile = resolveProfile(webmResult.profileName);
       invariant(
@@ -349,6 +343,7 @@ export async function runRecordExportCommand(
         profileName: webmResult.profileName,
         renderProfileHash,
         timingMode: webmResult.timingMode,
+        rendererBackend: webmResult.rendererBackend,
         outputEventCount: webmResult.outputEventCount,
         resizeEventCount: webmResult.resizeEventCount,
       };
@@ -358,6 +353,7 @@ export async function runRecordExportCommand(
         profileName: webmResult.profileName,
         renderProfileHash,
         timingMode: webmResult.timingMode,
+        rendererBackend: webmResult.rendererBackend,
         outputEventCount: webmResult.outputEventCount,
         resizeEventCount: webmResult.resizeEventCount,
       };
diff --git a/src/cli/commands/screenshot.ts b/src/cli/commands/screenshot.ts
index dc983b7..c93ca6e 100644
--- a/src/cli/commands/screenshot.ts
+++ b/src/cli/commands/screenshot.ts
@@ -130,11 +130,12 @@ function parseScreenshotResult(
 
 async function runOfflineScreenshot(
   sessionDirectory: string,
+  rendererName: CommandContext['rendererDefault'],
   profile: string,
   showCursor: boolean | undefined,
 ): Promise<ScreenshotResult> {
   return withOfflineReplayRenderer(
-    { sessionDir: sessionDirectory, profileName: profile },
+    { sessionDir: sessionDirectory, profileName: profile, rendererName },
     async ({ backend, manifest }) => {
       await ensureArtifactsDir(sessionDirectory);
       const temporaryOutputPath = artifactPath(
@@ -258,6 +259,7 @@ export async function runScreenshotCommand(
     try {
       rawResult = await sendRpc(socketPath(sessionDirectory), 'screenshot', {
         profile,
+        rendererName: options.context.rendererDefault,
         ...(showCursor === undefined ? {} : { showCursor }),
       });
     } catch (error) {
@@ -270,6 +272,7 @@ export async function runScreenshotCommand(
 
       rawResult = await runOfflineScreenshot(
         sessionDirectory,
+        options.context.rendererDefault,
         profile,
         showCursor,
       );
@@ -278,6 +281,7 @@ export async function runScreenshotCommand(
   } else {
     rawResult = await runOfflineScreenshot(
       sessionDirectory,
+      options.context.rendererDefault,
       profile,
       showCursor,
     );
diff --git a/src/cli/commands/snapshot.ts b/src/cli/commands/snapshot.ts
index fb2e6b1..4358a06 100644
--- a/src/cli/commands/snapshot.ts
+++ b/src/cli/commands/snapshot.ts
@@ -179,6 +179,7 @@ async function persistSnapshotArtifact(
 
 async function runRpcSnapshot(
   sessionDirectory: string,
+  rendererName: CommandContext['rendererDefault'],
   format: SnapshotFormat,
   includeScrollback: boolean,
   includeCells: boolean,
@@ -190,6 +191,7 @@ async function runRpcSnapshot(
       format,
       includeScrollback,
       includeCells,
+      rendererName,
     },
   );
 
@@ -198,12 +200,13 @@ async function runRpcSnapshot(
 
 async function runOfflineSnapshot(
   sessionDirectory: string,
+  rendererName: CommandContext['rendererDefault'],
   format: SnapshotFormat,
   includeScrollback: boolean,
   includeCells: boolean,
 ): Promise<SnapshotResult> {
   return withOfflineReplayRenderer(
-    { sessionDir: sessionDirectory },
+    { sessionDir: sessionDirectory, rendererName },
     async ({ backend }) => {
       const snapshot: SemanticSnapshot = await backend.snapshot({
         includeScrollback,
@@ -313,6 +316,7 @@ export async function runSnapshotCommand(
     try {
       result = await runRpcSnapshot(
         sessionDirectory,
+        options.context.rendererDefault,
         format,
         includeScrollback,
         includeCells,
@@ -324,6 +328,7 @@ export async function runSnapshotCommand(
       ) {
         result = await runOfflineSnapshot(
           sessionDirectory,
+          options.context.rendererDefault,
           format,
           includeScrollback,
           includeCells,
@@ -335,6 +340,7 @@ export async function runSnapshotCommand(
   } else {
     result = await runOfflineSnapshot(
       sessionDirectory,
+      options.context.rendererDefault,
       format,
       includeScrollback,
       includeCells,
diff --git a/src/cli/commands/wait.ts b/src/cli/commands/wait.ts
index 6aaae67..c58b7ac 100644
--- a/src/cli/commands/wait.ts
+++ b/src/cli/commands/wait.ts
@@ -172,13 +172,14 @@ function buildOfflineRenderWaitResult(
 
 async function runOfflineRenderWait(
   sessionDirectory: string,
+  rendererName: CommandContext['rendererDefault'],
   options: Pick<
     CommandOptions,
     'text' | 'regex' | 'screenStableMs' | 'cursorRow' | 'cursorCol'
   >,
 ): Promise<WaitForRenderResult> {
   return await withOfflineReplayRenderer(
-    { sessionDir: sessionDirectory },
+    { sessionDir: sessionDirectory, rendererName },
     async ({ backend }) => {
       const snapshot = await backend.snapshot({ includeScrollback: false });
       return buildOfflineRenderWaitResult(snapshot, options);
@@ -270,6 +271,7 @@ export async function runWaitCommand(options: CommandOptions): Promise<void> {
       cursorRow: options.cursorRow,
       cursorCol: options.cursorCol,
       timeoutMs: effectiveTimeout === 0 ? undefined : effectiveTimeout,
+      rendererName: options.context.rendererDefault,
     };
     const clientTimeout = effectiveTimeout === 0 ? 0 : effectiveTimeout + 5_000;
     let rawResult: unknown;
@@ -285,7 +287,11 @@ export async function runWaitCommand(options: CommandOptions): Promise<void> {
         error instanceof CliError &&
         error.code === ERROR_CODES.HOST_UNREACHABLE
       ) {
-        rawResult = await runOfflineRenderWait(sessionDirectory, options);
+        rawResult = await runOfflineRenderWait(
+          sessionDirectory,
+          options.context.rendererDefault,
+          options,
+        );
       } else {
         throw error;
       }
diff --git a/src/cli/context.ts b/src/cli/context.ts
index c509fe5..a21db6c 100644
--- a/src/cli/context.ts
+++ b/src/cli/context.ts
@@ -6,6 +6,11 @@ import type { Command } from 'commander';
 
 import { loadConfigFile, type ConfigFile } from '../config/resolveConfig.js';
 import { ERROR_CODES, makeCliError } from '../protocol/errors.js';
+import {
+  DEFAULT_RENDERER_NAME,
+  resolveRendererName,
+  type RendererName,
+} from '../renderer/names.js';
 import { resolveHome } from '../storage/home.js';
 import { invariant } from '../util/assert.js';
 import {
@@ -23,6 +28,7 @@ export interface GlobalCliOptions {
   logLevel?: string;
   profile?: string;
   profileDefault?: string;
+  renderer?: string;
 }
 
 export interface CommandContext {
@@ -32,6 +38,7 @@ export interface CommandContext {
   readonly logLevel: LogLevel;
   readonly logger: ReturnType<typeof createLogger>;
   readonly profileDefault: string | undefined;
+  readonly rendererDefault: RendererName;
   readonly configFile: ConfigFile | null;
 }
 
@@ -86,6 +93,18 @@ export function parseTimeoutMsOption(value: string): number {
   return parsedValue;
 }
 
+export function resolveRendererDefault(raw?: string): RendererName {
+  try {
+    return resolveRendererName(raw ?? DEFAULT_RENDERER_NAME);
+  } catch (error) {
+    throw makeCliError(ERROR_CODES.INVALID_INPUT, {
+      message: 'Renderer must be one of: ghostty-web, libghostty-vt.',
+      details: { renderer: raw },
+      cause: error,
+    });
+  }
+}
+
 export function resolveLogLevel(raw?: string): LogLevel {
   try {
     return resolveLoggerLevel(raw);
@@ -122,6 +141,12 @@ export async function resolveCommandContext(
     options.profile ??
     env.AGENT_TTY_PROFILE ??
     configFile?.defaultProfile;
+  const rendererDefault = resolveRendererDefault(
+    options.renderer ??
+      env.AGENT_TTY_RENDERER ??
+      configFile?.defaultRenderer ??
+      DEFAULT_RENDERER_NAME,
+  );
 
   return Object.freeze({
     home,
@@ -130,6 +155,7 @@ export async function resolveCommandContext(
     logLevel,
     logger,
     profileDefault,
+    rendererDefault,
     configFile,
   });
 }
diff --git a/src/cli/main.ts b/src/cli/main.ts
index 2ba7c5e..72cae9b 100644
--- a/src/cli/main.ts
+++ b/src/cli/main.ts
@@ -94,6 +94,7 @@ function wrapAction<Args extends unknown[]>(
       setColorEnabled(context.colorEnabled);
       context.logger.debug(`starting ${commandName} command`, {
         logLevel: context.logLevel,
+        renderer: context.rendererDefault,
       });
       const args = rawArgs.slice(0, -1) as Args;
       await fn(...([...args, context] as [...Args, CommandContext]));
@@ -130,7 +131,11 @@ async function main(): Promise<void> {
     )
     .option('--no-color', 'Disable ANSI color in human-readable output')
     .option('--log-level <level>', 'Set log level (debug, info, warn, error)')
-    .option('--profile <name>', 'Default render profile name');
+    .option('--profile <name>', 'Default render profile name')
+    .option(
+      '--renderer <name>',
+      'Renderer backend (ghostty-web or libghostty-vt)',
+    );
 
   program.hook('preAction', async (_thisCommand, actionCommand) => {
     const context = await resolveCommandContext(
@@ -144,6 +149,7 @@ async function main(): Promise<void> {
     // and constructor is a larger refactor with no user-visible benefit, since
     // the env var is set before any command handler runs.
     process.env.AGENT_TTY_LOG_LEVEL = context.logLevel;
+    process.env.AGENT_TTY_RENDERER = context.rendererDefault;
     setColorEnabled(context.colorEnabled);
     setCommandContext(actionCommand, context);
     context.logger.debug('resolved command context', {
diff --git a/src/config/resolveConfig.ts b/src/config/resolveConfig.ts
index 91f66d4..81837bc 100644
--- a/src/config/resolveConfig.ts
+++ b/src/config/resolveConfig.ts
@@ -18,6 +18,7 @@ export const ConfigFileSchema = z
   .object({
     logLevel: z.enum(['debug', 'info', 'warn', 'error']).optional(),
     defaultProfile: z.string().optional(),
+    defaultRenderer: z.string().optional(),
     defaultShell: z.string().optional(),
     defaultTerm: z.string().optional(),
     defaultCols: z.number().int().positive().optional(),
diff --git a/src/export/webm.ts b/src/export/webm.ts
index cecdad4..caa23cf 100644
--- a/src/export/webm.ts
+++ b/src/export/webm.ts
@@ -15,6 +15,11 @@ import type {
   VideoRecordingOptions,
 } from '../renderer/backend.js';
 import { GhosttyWebBackend } from '../renderer/ghosttyWeb/backend.js';
+import {
+  DEFAULT_RENDERER_NAME,
+  resolveRendererName,
+  type RendererName,
+} from '../renderer/names.js';
 import { resolveProfile } from '../renderer/profiles.js';
 import type { RenderProfileConfig, ReplayState } from '../renderer/types.js';
 import { invariant, unreachable } from '../util/assert.js';
@@ -51,10 +56,12 @@ export interface WebmExportOptions {
   targetSeq?: number;
   profileName?: string;
   timingMode?: ReplayTimingMode;
+  rendererName?: RendererName;
 }
 
 export interface WebmExportDeps {
   backendFactory?: (
+    rendererName: RendererName,
     sessionId: string,
     profile: RenderProfileConfig,
     videoOptions: VideoRecordingOptions,
@@ -71,13 +78,19 @@ export interface WebmExportResult {
   rows: number;
   profileName: string;
   timingMode: ReplayTimingMode;
+  rendererBackend: RendererName;
 }
 
 function createDefaultBackend(
+  rendererName: RendererName,
   sessionId: string,
   profile: RenderProfileConfig,
   videoOptions: VideoRecordingOptions,
 ): VideoCapableRendererBackend {
+  invariant(
+    rendererName === 'ghostty-web',
+    'WebM export currently requires the ghostty-web renderer backend',
+  );
   return new GhosttyWebBackend(sessionId, profile, videoOptions);
 }
 
@@ -163,13 +176,26 @@ export async function generateWebmExport(
       options.timingMode ?? 'accelerated';
     const timingOptions = buildReplayTimingOptions(resolvedTimingMode);
     const backendFactory = deps?.backendFactory ?? createDefaultBackend;
+    const requestedRendererName = resolveRendererName(
+      options.rendererName ?? DEFAULT_RENDERER_NAME,
+    );
+    // libghostty-vt is semantic-only; WebM output must be produced by ghostty-web.
+    const videoRendererName: RendererName =
+      requestedRendererName === 'libghostty-vt'
+        ? 'ghostty-web'
+        : requestedRendererName;
     const replayTimeoutMs = deps?.replayTimeoutMs ?? REPLAY_TIMEOUT_MS;
 
     invariant(
       replayTimeoutMs > 0,
       'replayTimeoutMs must be a positive number when provided',
     );
-    backend = backendFactory(options.sessionId, profile, videoOptions);
+    backend = backendFactory(
+      videoRendererName,
+      options.sessionId,
+      profile,
+      videoOptions,
+    );
 
     await backend.boot();
 
@@ -223,6 +249,7 @@ export async function generateWebmExport(
       rows: replayState.rows,
       profileName,
       timingMode: resolvedTimingMode,
+      rendererBackend: videoRendererName,
     };
   } finally {
     if (backend !== null) {
diff --git a/src/host/hostMain.ts b/src/host/hostMain.ts
index 39b0e74..e75ffdb 100644
--- a/src/host/hostMain.ts
+++ b/src/host/hostMain.ts
@@ -29,8 +29,13 @@ import type {
   WaitForRenderResult,
   WaitParams,
 } from '../protocol/messages.js';
-import { GhosttyWebBackend } from '../renderer/ghosttyWeb/index.js';
+import {
+  DEFAULT_RENDERER_NAME,
+  resolveRendererName,
+  type RendererName,
+} from '../renderer/names.js';
 import { resolveProfile } from '../renderer/profiles.js';
+import { createRendererBackend } from '../renderer/registry.js';
 import {
   appendArtifact,
   createArtifactEntry,
@@ -97,6 +102,20 @@ function rethrowAsync(error: unknown): void {
   });
 }
 
+function resolveHostRendererName(input: string | undefined): RendererName {
+  try {
+    return resolveRendererName(
+      input ?? process.env.AGENT_TTY_RENDERER ?? DEFAULT_RENDERER_NAME,
+    );
+  } catch (error) {
+    throw makeCliError(ERROR_CODES.INVALID_INPUT, {
+      message: 'Renderer must be one of: ghostty-web, libghostty-vt.',
+      details: { renderer: input ?? process.env.AGENT_TTY_RENDERER },
+      cause: error,
+    });
+  }
+}
+
 function isRegexQuantifierAt(pattern: string, index: number): boolean {
   const nextChar = pattern[index];
   if (nextChar === '*' || nextChar === '+' || nextChar === '?') {
@@ -234,7 +253,8 @@ export async function runHost(sessionId: string): Promise<void> {
   const rendererManager = new HostRendererManager({
     sessionId,
     sessionDir: sessDir,
-    backendFactory: (sid, profile) => new GhosttyWebBackend(sid, profile),
+    backendFactory: (rendererName, sid, profile) =>
+      createRendererBackend(rendererName, sid, profile),
   });
 
   const loadReplayInput = () => {
@@ -396,6 +416,7 @@ export async function runHost(sessionId: string): Promise<void> {
         format: requestedFormat,
         includeScrollback: requestedIncludeScrollback,
         includeCells: requestedIncludeCells,
+        rendererName: requestedRendererName,
       } = params as SnapshotParams;
 
       const format = requestedFormat ?? 'structured';
@@ -411,9 +432,14 @@ export async function runHost(sessionId: string): Promise<void> {
         'snapshot includeCells must normalize to a boolean',
       );
 
+      const rendererName = resolveHostRendererName(requestedRendererName);
       const profile = resolveProfile(DEFAULT_RENDER_PROFILE_NAME);
       const replayInput = loadReplayInput();
-      const backend = await rendererManager.getBackend(profile, replayInput);
+      const backend = await rendererManager.getBackend(
+        rendererName,
+        profile,
+        replayInput,
+      );
       const snapshot = await backend.snapshot({
         includeScrollback,
         includeCells,
@@ -479,8 +505,11 @@ export async function runHost(sessionId: string): Promise<void> {
       return snapshotResult;
     },
     screenshot: async (params: unknown) => {
-      const { profile: requestedProfileName, showCursor } =
-        params as ScreenshotParams;
+      const {
+        profile: requestedProfileName,
+        rendererName: requestedRendererName,
+        showCursor,
+      } = params as ScreenshotParams;
 
       const profile = (() => {
         try {
@@ -501,8 +530,13 @@ export async function runHost(sessionId: string): Promise<void> {
         }
       })();
 
+      const rendererName = resolveHostRendererName(requestedRendererName);
       const replayInput = loadReplayInput();
-      const backend = await rendererManager.getBackend(profile, replayInput);
+      const backend = await rendererManager.getBackend(
+        rendererName,
+        profile,
+        replayInput,
+      );
       await ensureArtifactsDir(sessDir);
       const temporaryOutputPath = artifactPath(
         sessDir,
@@ -685,6 +719,7 @@ export async function runHost(sessionId: string): Promise<void> {
 
       const effectiveTimeoutMs = timeoutMs ?? 30_000;
       const startTime = Date.now();
+      const rendererName = resolveHostRendererName(undefined);
       const profile = resolveProfile(DEFAULT_RENDER_PROFILE_NAME);
       const pollIntervalMs = 200;
       const waitMarker = marker;
@@ -708,6 +743,7 @@ export async function runHost(sessionId: string): Promise<void> {
             try {
               const replayInput = loadReplayInput();
               const backend = await rendererManager.getBackend(
+                rendererName,
                 profile,
                 replayInput,
               );
@@ -1012,8 +1048,15 @@ export async function runHost(sessionId: string): Promise<void> {
       });
     },
     waitForRender: async (params: unknown) => {
-      const { text, regex, screenStableMs, cursorRow, cursorCol, timeoutMs } =
-        params as WaitForRenderParams;
+      const {
+        text,
+        regex,
+        screenStableMs,
+        cursorRow,
+        cursorCol,
+        timeoutMs,
+        rendererName: requestedRendererName,
+      } = params as WaitForRenderParams;
 
       invariant(
         text !== undefined ||
@@ -1074,6 +1117,7 @@ export async function runHost(sessionId: string): Promise<void> {
         }
       }
 
+      const rendererName = resolveHostRendererName(requestedRendererName);
       const profile = resolveProfile(DEFAULT_RENDER_PROFILE_NAME);
       const pollIntervalMs = 200;
       let lastVisibleText: string | undefined;
@@ -1095,6 +1139,7 @@ export async function runHost(sessionId: string): Promise<void> {
             try {
               const replayInput = loadReplayInput();
               const backend = await rendererManager.getBackend(
+                rendererName,
                 profile,
                 replayInput,
               );
diff --git a/src/host/renderer.ts b/src/host/renderer.ts
index 39ecc8e..66796b2 100644
--- a/src/host/renderer.ts
+++ b/src/host/renderer.ts
@@ -2,6 +2,8 @@ import { mkdirSync } from 'node:fs';
 import { dirname, isAbsolute, relative, resolve, sep } from 'node:path';
 
 import type { RendererBackend } from '../renderer/backend.js';
+import type { RendererName } from '../renderer/names.js';
+import { hashProfile } from '../renderer/profiles.js';
 import type { RenderProfileConfig, ReplayInput } from '../renderer/types.js';
 import { invariant } from '../util/assert.js';
 
@@ -9,9 +11,10 @@ interface HostRendererManagerOptions {
   sessionId: string;
   sessionDir: string;
   backendFactory: (
+    rendererName: RendererName,
     sessionId: string,
     profile: RenderProfileConfig,
-  ) => RendererBackend;
+  ) => RendererBackend | Promise<RendererBackend>;
 }
 
 function assertNonEmptyString(
@@ -35,7 +38,7 @@ export class HostRendererManager {
   private readonly backendFactory: HostRendererManagerOptions['backendFactory'];
 
   private currentBackend: RendererBackend | null = null;
-  private currentProfileName: string | null = null;
+  private currentBackendKey: string | null = null;
   private cachedInitialCols: number | null = null;
   private cachedInitialRows: number | null = null;
   private bootPromise: Promise<RendererBackend> | null = null;
@@ -56,9 +59,11 @@ export class HostRendererManager {
   }
 
   async getBackend(
+    rendererName: RendererName,
     profile: RenderProfileConfig,
     replayInput: ReplayInput | null,
   ): Promise<RendererBackend> {
+    assertNonEmptyString(rendererName, 'rendererName');
     assertNonEmptyString(profile.name, 'profile name');
 
     if (replayInput !== null) {
@@ -80,7 +85,7 @@ export class HostRendererManager {
         await this.disposeCurrentBackend();
       }
 
-      const backend = await this.ensureBackend(profile);
+      const backend = await this.ensureBackend(rendererName, profile);
 
       if (replayInput !== null && replayInput.targetSeq >= 0) {
         await backend.replayTo(replayInput);
@@ -133,20 +138,26 @@ export class HostRendererManager {
   }
 
   private async ensureBackend(
+    rendererName: RendererName,
     profile: RenderProfileConfig,
   ): Promise<RendererBackend> {
+    const backendKey = `${rendererName}:${hashProfile(profile)}`;
     const requiresReplacement =
       this.currentBackend === null ||
-      this.currentProfileName !== profile.name ||
+      this.currentBackendKey !== backendKey ||
       !this.currentBackend.isBooted;
 
     if (requiresReplacement) {
       await this.disposeCurrentBackend();
 
-      const backend = this.backendFactory(this.sessionId, profile);
+      const backend = await this.backendFactory(
+        rendererName,
+        this.sessionId,
+        profile,
+      );
 
       this.currentBackend = backend;
-      this.currentProfileName = profile.name;
+      this.currentBackendKey = backendKey;
     }
 
     invariant(this.currentBackend !== null, 'current backend must exist');
@@ -191,7 +202,7 @@ export class HostRendererManager {
     const backend = this.currentBackend;
 
     this.currentBackend = null;
-    this.currentProfileName = null;
+    this.currentBackendKey = null;
     this.cachedInitialCols = null;
     this.cachedInitialRows = null;
     this.bootPromise = null;
diff --git a/src/protocol/schemas.ts b/src/protocol/schemas.ts
index 57c1598..e2d3244 100644
--- a/src/protocol/schemas.ts
+++ b/src/protocol/schemas.ts
@@ -1,5 +1,7 @@
 import { z } from 'zod';
 
+import { RendererNameSchema } from '../renderer/names.js';
+
 const NonEmptyStringSchema = z.string().min(1);
 const TextMatchSchema = z.string().min(1).max(1000);
 const RegexPatternSchema = z.string().min(1).max(200);
@@ -295,6 +297,7 @@ export const SnapshotParamsSchema = z
     format: SnapshotFormatSchema.optional(),
     includeScrollback: z.boolean().optional(),
     includeCells: z.boolean().optional(),
+    rendererName: RendererNameSchema.optional(),
   })
   .strict();
 export type SnapshotParams = z.infer<typeof SnapshotParamsSchema>;
@@ -342,6 +345,7 @@ export const ScreenshotParamsSchema = z
   .object({
     profile: ProfileNameSchema.optional(),
     showCursor: z.boolean().optional(),
+    rendererName: RendererNameSchema.optional(),
   })
   .strict();
 export type ScreenshotParams = z.infer<typeof ScreenshotParamsSchema>;
@@ -373,6 +377,7 @@ export const WaitForRenderParamsSchema = z
     cursorRow: NonNegativeIntSchema.optional(),
     cursorCol: NonNegativeIntSchema.optional(),
     timeoutMs: PositiveIntSchema.optional(),
+    rendererName: RendererNameSchema.optional(),
   })
   .strict()
   .superRefine((value, ctx) => {
diff --git a/src/renderer/index.ts b/src/renderer/index.ts
index 07dc0c4..dd9439e 100644
--- a/src/renderer/index.ts
+++ b/src/renderer/index.ts
@@ -15,6 +15,13 @@ export {
 } from './types.js';
 export { VisibleLineSchema } from '../protocol/schemas.js';
 export type { RendererBackend, SnapshotOptions } from './backend.js';
+export {
+  DEFAULT_RENDERER_NAME,
+  RendererNameSchema,
+  resolveRendererName,
+} from './names.js';
+export type { RendererName } from './names.js';
+export { createRendererBackend } from './registry.js';
 export { GhosttyWebBackend } from './ghosttyWeb/index.js';
 export type {
   RenderProfileConfig,
diff --git a/src/renderer/libghosttyVt/backend.ts b/src/renderer/libghosttyVt/backend.ts
new file mode 100644
index 0000000..6a065b0
--- /dev/null
+++ b/src/renderer/libghosttyVt/backend.ts
@@ -0,0 +1,690 @@
+import { isAbsolute } from 'node:path';
+
+import type {
+  CreateTerminalOptions,
+  GhosttyVtTerminal,
+  NativeInfo,
+  SnapshotCell as NativeSnapshotCell,
+  TerminalSnapshot,
+  VisibleLine as NativeVisibleLine,
+} from '@coder/libghostty-vt-node';
+
+import type {
+  RendererBackend,
+  ScreenshotOptions,
+  SnapshotOptions,
+} from '../backend.js';
+import { GhosttyWebBackend } from '../ghosttyWeb/backend.js';
+import type {
+  RenderProfileConfig,
+  ReplayInput,
+  ReplayState,
+  ScreenshotResult,
+  SemanticSnapshot,
+} from '../types.js';
+import { SemanticSnapshotSchema } from '../types.js';
+import { DEFAULT_COLS, DEFAULT_ROWS } from '../../config/defaults.js';
+import { invariant, assertString, unreachable } from '../../util/assert.js';
+import { Logger, createProcessLogger } from '../../util/logger.js';
+
+export interface LibghosttyVtNativeModule {
+  createTerminal(options: CreateTerminalOptions): GhosttyVtTerminal;
+  getNativeInfo?: () => NativeInfo;
+}
+
+export interface LibghosttyVtBackendOptions {
+  initialCols?: number;
+  initialRows?: number;
+  scrollbackLimit?: number;
+  loadNative?: () => Promise<LibghosttyVtNativeModule>;
+  fallbackFactory?: (
+    sessionId: string,
+    profile: RenderProfileConfig,
+    options?: unknown,
+  ) => RendererBackend;
+  logger?: Logger;
+}
+
+type NativeSnapshotBooleanKey = 'bold' | 'italic' | 'underline';
+type NativeSnapshotStringKey = 'foreground' | 'background';
+
+function assertPositiveInteger(
+  value: unknown,
+  message: string,
+): asserts value is number {
+  invariant(
+    typeof value === 'number' && Number.isInteger(value) && value > 0,
+    message,
+  );
+}
+
+function assertNonNegativeInteger(
+  value: unknown,
+  message: string,
+): asserts value is number {
+  invariant(
+    typeof value === 'number' && Number.isInteger(value) && value >= 0,
+    message,
+  );
+}
+
+function cloneReplayInput(input: ReplayInput): ReplayInput {
+  return {
+    sessionId: input.sessionId,
+    initialCols: input.initialCols,
+    initialRows: input.initialRows,
+    targetSeq: input.targetSeq,
+    events: input.events.map((event) => ({
+      ...event,
+      payload: { ...event.payload },
+    })) as ReplayInput['events'],
+  };
+}
+
+function validateNativeVisibleLines(
+  lines: unknown,
+  label: string,
+): NativeVisibleLine[] {
+  invariant(Array.isArray(lines), `${label} must be an array`);
+
+  let previousRow = -1;
+  return lines.map((line, index) => {
+    invariant(
+      line !== null && typeof line === 'object',
+      `${label}[${String(index)}] must be an object`,
+    );
+    const candidate = line as { row?: unknown; text?: unknown };
+    assertNonNegativeInteger(
+      candidate.row,
+      `${label}[${String(index)}].row must be a non-negative integer`,
+    );
+    assertString(
+      candidate.text,
+      `${label}[${String(index)}].text must be a string`,
+    );
+    invariant(
+      candidate.row > previousRow,
+      `${label} rows must be strictly increasing`,
+    );
+    previousRow = candidate.row;
+
+    return { row: candidate.row, text: candidate.text };
+  });
+}
+
+function assertNativeSnapshot(snapshot: unknown): TerminalSnapshot {
+  invariant(
+    snapshot !== null && typeof snapshot === 'object',
+    'libghostty-vt snapshot must be an object',
+  );
+  const candidate = snapshot as {
+    cols?: unknown;
+    rows?: unknown;
+    cursorRow?: unknown;
+    cursorCol?: unknown;
+    isAltScreen?: unknown;
+    visibleLines?: unknown;
+    scrollbackLines?: unknown;
+    cells?: unknown;
+  };
+
+  assertPositiveInteger(candidate.cols, 'snapshot cols must be positive');
+  assertPositiveInteger(candidate.rows, 'snapshot rows must be positive');
+  assertNonNegativeInteger(
+    candidate.cursorRow,
+    'snapshot cursorRow must be non-negative',
+  );
+  assertNonNegativeInteger(
+    candidate.cursorCol,
+    'snapshot cursorCol must be non-negative',
+  );
+  invariant(
+    candidate.cursorRow < candidate.rows,
+    'snapshot cursorRow must be within rows',
+  );
+  invariant(
+    candidate.cursorCol < candidate.cols,
+    'snapshot cursorCol must be within cols',
+  );
+  invariant(
+    typeof candidate.isAltScreen === 'boolean',
+    'snapshot isAltScreen must be a boolean',
+  );
+
+  const visibleLines = validateNativeVisibleLines(
+    candidate.visibleLines,
+    'snapshot.visibleLines',
+  );
+  invariant(
+    visibleLines.length <= candidate.rows,
+    'snapshot visible line count must fit terminal rows',
+  );
+  const scrollbackLines =
+    candidate.scrollbackLines === undefined
+      ? undefined
+      : validateNativeVisibleLines(
+          candidate.scrollbackLines,
+          'snapshot.scrollbackLines',
+        );
+  const cells =
+    candidate.cells === undefined
+      ? undefined
+      : validateNativeCells(candidate.cells);
+
+  return {
+    cols: candidate.cols,
+    rows: candidate.rows,
+    cursorRow: candidate.cursorRow,
+    cursorCol: candidate.cursorCol,
+    isAltScreen: candidate.isAltScreen,
+    visibleLines,
+    ...(scrollbackLines === undefined ? {} : { scrollbackLines }),
+    ...(cells === undefined ? {} : { cells }),
+  };
+}
+
+function validateNativeCells(cells: unknown): NativeSnapshotCell[] {
+  invariant(Array.isArray(cells), 'snapshot cells must be an array');
+
+  return cells.map((cell, index) => {
+    invariant(
+      cell !== null && typeof cell === 'object',
+      `snapshot.cells[${String(index)}] must be an object`,
+    );
+    const candidate = cell as {
+      row?: unknown;
+      col?: unknown;
+      text?: unknown;
+      width?: unknown;
+      bold?: unknown;
+      italic?: unknown;
+      underline?: unknown;
+      foreground?: unknown;
+      background?: unknown;
+    };
+    assertNonNegativeInteger(
+      candidate.row,
+      `snapshot.cells[${String(index)}].row must be non-negative`,
+    );
+    assertNonNegativeInteger(
+      candidate.col,
+      `snapshot.cells[${String(index)}].col must be non-negative`,
+    );
+    assertString(
+      candidate.text,
+      `snapshot.cells[${String(index)}].text must be a string`,
+    );
+    assertPositiveInteger(
+      candidate.width,
+      `snapshot.cells[${String(index)}].width must be positive`,
+    );
+
+    const validatedCell: NativeSnapshotCell = {
+      row: candidate.row,
+      col: candidate.col,
+      text: candidate.text,
+      width: candidate.width,
+    };
+    copyOptionalBoolean(candidate, validatedCell, 'bold');
+    copyOptionalBoolean(candidate, validatedCell, 'italic');
+    copyOptionalBoolean(candidate, validatedCell, 'underline');
+    copyOptionalString(candidate, validatedCell, 'foreground');
+    copyOptionalString(candidate, validatedCell, 'background');
+    return validatedCell;
+  });
+}
+
+function copyOptionalBoolean(
+  source: { [key: string]: unknown },
+  target: NativeSnapshotCell,
+  key: NativeSnapshotBooleanKey,
+): void {
+  const value = source[key];
+  invariant(
+    value === undefined || typeof value === 'boolean',
+    `snapshot cell ${key} must be a boolean when provided`,
+  );
+  if (typeof value === 'boolean') {
+    target[key] = value;
+  }
+}
+
+function copyOptionalString(
+  source: { [key: string]: unknown },
+  target: NativeSnapshotCell,
+  key: NativeSnapshotStringKey,
+): void {
+  const value = source[key];
+  invariant(
+    value === undefined || typeof value === 'string',
+    `snapshot cell ${key} must be a string when provided`,
+  );
+  if (typeof value === 'string') {
+    target[key] = value;
+  }
+}
+
+function mapNativeCells(
+  nativeCells: readonly NativeSnapshotCell[] | undefined,
+): SemanticSnapshot['cells'] | undefined {
+  if (nativeCells === undefined) {
+    return undefined;
+  }
+
+  const grouped = new Map<number, NativeSnapshotCell[]>();
+  for (const cell of nativeCells) {
+    const rowCells = grouped.get(cell.row) ?? [];
+    rowCells.push(cell);
+    grouped.set(cell.row, rowCells);
+  }
+
+  return [...grouped.entries()]
+    .sort(([leftRow], [rightRow]) => leftRow - rightRow)
+    .map(([lineNumber, rowCells]) => ({
+      lineNumber,
+      cells: rowCells
+        .sort((left, right) => left.col - right.col)
+        .map((cell) => ({
+          char: cell.text,
+          ...(cell.foreground === undefined ? {} : { fg: cell.foreground }),
+          ...(cell.background === undefined ? {} : { bg: cell.background }),
+          ...(cell.bold === undefined ? {} : { bold: cell.bold }),
+          ...(cell.italic === undefined ? {} : { italic: cell.italic }),
+          ...(cell.underline === undefined
+            ? {}
+            : { underline: cell.underline }),
+        })),
+    }));
+}
+
+export class LibghosttyVtBackend implements RendererBackend {
+  public readonly rendererBackend = 'libghostty-vt';
+  public isBooted = false;
+
+  private readonly fallbackFactory: NonNullable<
+    LibghosttyVtBackendOptions['fallbackFactory']
+  >;
+  private readonly initialCols: number;
+  private readonly initialRows: number;
+  private readonly loadNative: NonNullable<
+    LibghosttyVtBackendOptions['loadNative']
+  >;
+  private readonly logger: Logger;
+  private readonly profile: RenderProfileConfig;
+  private readonly scrollbackLimit: number | undefined;
+  private readonly sessionId: string;
+
+  private bootPromise: Promise<void> | null = null;
+  private currentCols: number;
+  private currentRows: number;
+  private disposed = false;
+  private fallbackBackend: RendererBackend | null = null;
+  private initialReplayCols: number | null = null;
+  private initialReplayRows: number | null = null;
+  private lastAppliedSeq = -1;
+  private latestReplayInput: ReplayInput | null = null;
+  private terminal: GhosttyVtTerminal | null = null;
+
+  public constructor(
+    sessionId: string,
+    profile: RenderProfileConfig,
+    options: LibghosttyVtBackendOptions = {},
+  ) {
+    invariant(sessionId.length > 0, 'sessionId must be a non-empty string');
+    invariant(profile.name.length > 0, 'profile.name must be non-empty');
+
+    const initialCols = options.initialCols ?? DEFAULT_COLS;
+    const initialRows = options.initialRows ?? DEFAULT_ROWS;
+    assertPositiveInteger(initialCols, 'initialCols must be positive');
+    assertPositiveInteger(initialRows, 'initialRows must be positive');
+    if (options.scrollbackLimit !== undefined) {
+      assertNonNegativeInteger(
+        options.scrollbackLimit,
+        'scrollbackLimit must be non-negative when provided',
+      );
+    }
+    if (options.logger !== undefined) {
+      invariant(options.logger instanceof Logger, 'logger must be a Logger');
+    }
+
+    this.sessionId = sessionId;
+    this.profile = Object.freeze({ ...profile });
+    this.initialCols = initialCols;
+    this.initialRows = initialRows;
+    this.currentCols = initialCols;
+    this.currentRows = initialRows;
+    this.scrollbackLimit = options.scrollbackLimit;
+    this.loadNative =
+      options.loadNative ??
+      (() =>
+        import('@coder/libghostty-vt-node') as Promise<LibghosttyVtNativeModule>);
+    this.fallbackFactory =
+      options.fallbackFactory ??
+      ((fallbackSessionId, fallbackProfile) =>
+        new GhosttyWebBackend(fallbackSessionId, fallbackProfile));
+    this.logger = options.logger ?? createProcessLogger();
+  }
+
+  public async boot(): Promise<void> {
+    this.assertNotDisposed('boot()');
+    if (this.isBooted) {
+      return;
+    }
+    if (this.bootPromise !== null) {
+      await this.bootPromise;
+      return;
+    }
+
+    this.bootPromise = this.bootInternal().finally(() => {
+      this.bootPromise = null;
+    });
+    await this.bootPromise;
+  }
+
+  public async replayTo(input: ReplayInput): Promise<ReplayState> {
+    await Promise.resolve();
+    const terminal = this.requireTerminal('replayTo()');
+    invariant(
+      input.sessionId === this.sessionId,
+      `replay input session ${input.sessionId} does not match backend session ${this.sessionId}`,
+    );
+    assertPositiveInteger(
+      input.initialCols,
+      'replay input initialCols must be positive',
+    );
+    assertPositiveInteger(
+      input.initialRows,
+      'replay input initialRows must be positive',
+    );
+    assertNonNegativeInteger(
+      input.targetSeq,
+      'replay input targetSeq must be non-negative',
+    );
+    invariant(
+      input.targetSeq >= this.lastAppliedSeq,
+      'stateful LibghosttyVtBackend cannot rewind from seq ' +
+        String(this.lastAppliedSeq) +
+        ' to ' +
+        String(input.targetSeq),
+    );
+
+    if (this.initialReplayCols === null || this.initialReplayRows === null) {
+      terminal.resize(input.initialCols, input.initialRows);
+      this.initialReplayCols = input.initialCols;
+      this.initialReplayRows = input.initialRows;
+      this.currentCols = input.initialCols;
+      this.currentRows = input.initialRows;
+    } else {
+      invariant(
+        this.initialReplayCols === input.initialCols &&
+          this.initialReplayRows === input.initialRows,
+        'replay input initial dimensions changed after first replay',
+      );
+    }
+
+    let previousEventSeq = -1;
+    let highestProcessedSeq = this.lastAppliedSeq;
+    for (const event of input.events) {
+      assertNonNegativeInteger(
+        event.seq,
+        'replay event seq must be non-negative',
+      );
+      invariant(
+        event.seq > previousEventSeq,
+        'replay events must be ordered by strictly increasing seq values',
+      );
+      previousEventSeq = event.seq;
+
+      if (event.seq <= this.lastAppliedSeq) {
+        continue;
+      }
+      if (event.seq > input.targetSeq) {
+        break;
+      }
+
+      switch (event.type) {
+        case 'output':
+          terminal.feed(event.payload.data);
+          break;
+        case 'resize':
+          assertPositiveInteger(
+            event.payload.cols,
+            'resize event cols must be positive',
+          );
+          assertPositiveInteger(
+            event.payload.rows,
+            'resize event rows must be positive',
+          );
+          terminal.resize(event.payload.cols, event.payload.rows);
+          this.currentCols = event.payload.cols;
+          this.currentRows = event.payload.rows;
+          break;
+        case 'marker':
+        case 'input_text':
+        case 'input_paste':
+        case 'input_keys':
+        case 'input_run':
+        case 'signal':
+        case 'exit':
+          break;
+        default:
+          unreachable(event, 'unsupported replay event type');
+      }
+
+      highestProcessedSeq = event.seq;
+    }
+
+    if (highestProcessedSeq < 0) {
+      highestProcessedSeq = input.targetSeq;
+    }
+    this.lastAppliedSeq = highestProcessedSeq;
+    this.latestReplayInput = cloneReplayInput(input);
+
+    const snapshot = assertNativeSnapshot(terminal.snapshot());
+    this.assertSnapshotDimensions(snapshot);
+    this.currentCols = snapshot.cols;
+    this.currentRows = snapshot.rows;
+
+    return {
+      lastSeq: this.lastAppliedSeq,
+      cols: snapshot.cols,
+      rows: snapshot.rows,
+      cursorRow: snapshot.cursorRow,
+      cursorCol: snapshot.cursorCol,
+    };
+  }
+
+  public async snapshot(options?: SnapshotOptions): Promise<SemanticSnapshot> {
+    await Promise.resolve();
+    const terminal = this.requireTerminal('snapshot()');
+    invariant(
+      this.lastAppliedSeq >= 0,
+      'snapshot() requires replayTo() to advance to a non-negative sequence first',
+    );
+    const nativeSnapshot = assertNativeSnapshot(terminal.snapshot(options));
+    this.assertSnapshotDimensions(nativeSnapshot);
+    this.currentCols = nativeSnapshot.cols;
+    this.currentRows = nativeSnapshot.rows;
+
+    const semanticSnapshot = {
+      sessionId: this.sessionId,
+      capturedAtSeq: this.lastAppliedSeq,
+      cols: nativeSnapshot.cols,
+      rows: nativeSnapshot.rows,
+      cursorRow: nativeSnapshot.cursorRow,
+      cursorCol: nativeSnapshot.cursorCol,
+      isAltScreen: nativeSnapshot.isAltScreen,
+      visibleLines: nativeSnapshot.visibleLines,
+      ...(nativeSnapshot.scrollbackLines === undefined
+        ? {}
+        : { scrollbackLines: nativeSnapshot.scrollbackLines }),
+      ...(nativeSnapshot.cells === undefined
+        ? {}
+        : { cells: mapNativeCells(nativeSnapshot.cells) }),
+    };
+
+    return SemanticSnapshotSchema.parse(semanticSnapshot);
+  }
+
+  public async screenshot(
+    outputPath: string,
+    options?: ScreenshotOptions,
+  ): Promise<ScreenshotResult> {
+    this.assertNotDisposed('screenshot()');
+    invariant(
+      this.latestReplayInput !== null,
+      'screenshot() requires replayTo() before ghostty-web fallback can render',
+    );
+    invariant(
+      outputPath.length > 0,
+      'screenshot outputPath must be a non-empty string',
+    );
+    invariant(isAbsolute(outputPath), 'screenshot outputPath must be absolute');
+
+    const fallback = await this.ensureFallbackBackend();
+    await fallback.replayTo(this.latestReplayInput);
+    return await fallback.screenshot(outputPath, options);
+  }
+
+  public async getVisibleText(): Promise<string> {
+    await Promise.resolve();
+    const terminal = this.requireTerminal('getVisibleText()');
+    const visibleText = terminal.getVisibleText();
+    assertString(visibleText, 'libghostty-vt visible text must be a string');
+    return visibleText;
+  }
+
+  public async dispose(): Promise<void> {
+    if (this.disposed) {
+      return;
+    }
+
+    this.disposed = true;
+    this.isBooted = false;
+    const terminal = this.terminal;
+    this.terminal = null;
+    if (terminal !== null) {
+      terminal.dispose();
+    }
+
+    const fallback = this.fallbackBackend;
+    this.fallbackBackend = null;
+    if (fallback !== null) {
+      await fallback.dispose();
+    }
+  }
+
+  private async bootInternal(): Promise<void> {
+    try {
+      const native = await this.loadNative();
+      invariant(
+        typeof native.createTerminal === 'function',
+        'libghostty-vt native module createTerminal must be a function',
+      );
+
+      if (typeof native.getNativeInfo === 'function') {
+        try {
+          this.logger.debug('Loaded libghostty-vt native renderer', {
+            nativeInfo: native.getNativeInfo(),
+          });
+        } catch (error) {
+          this.logger.debug('libghostty-vt native info unavailable', {
+            error: error instanceof Error ? error.message : String(error),
+          });
+        }
+      }
+
+      this.terminal = native.createTerminal({
+        cols: this.initialCols,
+        rows: this.initialRows,
+        ...(this.scrollbackLimit === undefined
+          ? {}
+          : { scrollbackLimit: this.scrollbackLimit }),
+      });
+      this.assertTerminalShape(this.terminal);
+      this.currentCols = this.initialCols;
+      this.currentRows = this.initialRows;
+      this.isBooted = true;
+    } catch (error) {
+      this.terminal = null;
+      this.isBooted = false;
+      throw new Error(
+        'Failed to boot renderer libghostty-vt via optional dependency @coder/libghostty-vt-node. Install a supported optional native package or retry with --renderer ghostty-web.',
+        { cause: error },
+      );
+    }
+  }
+
+  private async ensureFallbackBackend(): Promise<RendererBackend> {
+    if (this.fallbackBackend === null) {
+      const fallback = this.fallbackFactory(this.sessionId, this.profile);
+      invariant(
+        fallback.rendererBackend !== this.rendererBackend,
+        'libghostty-vt screenshot fallback must use a different renderer backend',
+      );
+      this.fallbackBackend = fallback;
+    }
+
+    if (!this.fallbackBackend.isBooted) {
+      await this.fallbackBackend.boot();
+    }
+    return this.fallbackBackend;
+  }
+
+  private assertNotDisposed(methodName: string): void {
+    invariant(
+      !this.disposed,
+      `LibghosttyVtBackend ${methodName} cannot be used after dispose()`,
+    );
+  }
+
+  private requireTerminal(methodName: string): GhosttyVtTerminal {
+    this.assertNotDisposed(methodName);
+    invariant(
+      this.isBooted && this.terminal !== null,
+      `LibghosttyVtBackend ${methodName} requires boot() first`,
+    );
+    return this.terminal;
+  }
+
+  private assertTerminalShape(
+    terminal: unknown,
+  ): asserts terminal is GhosttyVtTerminal {
+    invariant(
+      terminal !== null && typeof terminal === 'object',
+      'libghostty-vt terminal must be an object',
+    );
+    const candidate = terminal as Partial<GhosttyVtTerminal>;
+    invariant(
+      typeof candidate.feed === 'function',
+      'terminal.feed is required',
+    );
+    invariant(
+      typeof candidate.resize === 'function',
+      'terminal.resize is required',
+    );
+    invariant(
+      typeof candidate.snapshot === 'function',
+      'terminal.snapshot is required',
+    );
+    invariant(
+      typeof candidate.getVisibleText === 'function',
+      'terminal.getVisibleText is required',
+    );
+    invariant(
+      typeof candidate.dispose === 'function',
+      'terminal.dispose is required',
+    );
+  }
+
+  private assertSnapshotDimensions(snapshot: TerminalSnapshot): void {
+    invariant(
+      snapshot.cols === this.currentCols,
+      `native snapshot cols ${String(snapshot.cols)} must match current cols ${String(this.currentCols)}`,
+    );
+    invariant(
+      snapshot.rows === this.currentRows,
+      `native snapshot rows ${String(snapshot.rows)} must match current rows ${String(this.currentRows)}`,
+    );
+  }
+}
diff --git a/src/renderer/libghosttyVt/index.ts b/src/renderer/libghosttyVt/index.ts
new file mode 100644
index 0000000..3f94f06
--- /dev/null
+++ b/src/renderer/libghosttyVt/index.ts
@@ -0,0 +1,5 @@
+export { LibghosttyVtBackend } from './backend.js';
+export type {
+  LibghosttyVtBackendOptions,
+  LibghosttyVtNativeModule,
+} from './backend.js';
diff --git a/src/renderer/names.ts b/src/renderer/names.ts
new file mode 100644
index 0000000..7e0f58f
--- /dev/null
+++ b/src/renderer/names.ts
@@ -0,0 +1,19 @@
+import { z } from 'zod';
+
+export const RendererNameSchema = z.enum(['ghostty-web', 'libghostty-vt']);
+export type RendererName = z.infer<typeof RendererNameSchema>;
+
+export const DEFAULT_RENDERER_NAME: RendererName = 'ghostty-web';
+
+export function resolveRendererName(input: string | undefined): RendererName {
+  const candidate = input ?? DEFAULT_RENDERER_NAME;
+  const result = RendererNameSchema.safeParse(candidate);
+  if (!result.success) {
+    throw new Error(
+      `Renderer must be one of: ${RendererNameSchema.options.join(', ')}. Received: ${candidate}`,
+      { cause: result.error },
+    );
+  }
+
+  return result.data;
+}
diff --git a/src/renderer/registry.ts b/src/renderer/registry.ts
new file mode 100644
index 0000000..3af9766
--- /dev/null
+++ b/src/renderer/registry.ts
@@ -0,0 +1,38 @@
+import type { RendererBackend } from './backend.js';
+import type * as LibghosttyVtBackendModule from './libghosttyVt/backend.js';
+import { GhosttyWebBackend } from './ghosttyWeb/index.js';
+import type { LibghosttyVtBackendOptions } from './libghosttyVt/backend.js';
+import { resolveRendererName, type RendererName } from './names.js';
+import type { RenderProfileConfig } from './types.js';
+import { invariant } from '../util/assert.js';
+
+export interface RendererRegistryOptions {
+  loadLibghosttyVtBackend?: () => Promise<typeof LibghosttyVtBackendModule>;
+  libghosttyVt?: LibghosttyVtBackendOptions;
+}
+
+export async function createRendererBackend(
+  rendererName: RendererName,
+  sessionId: string,
+  profile: RenderProfileConfig,
+  options: RendererRegistryOptions = {},
+): Promise<RendererBackend> {
+  invariant(sessionId.length > 0, 'sessionId must be a non-empty string');
+  invariant(profile.name.length > 0, 'profile.name must be a non-empty string');
+
+  switch (resolveRendererName(rendererName)) {
+    case 'ghostty-web':
+      return new GhosttyWebBackend(sessionId, profile);
+    case 'libghostty-vt': {
+      const module = await (
+        options.loadLibghosttyVtBackend ??
+        (() => import('./libghosttyVt/backend.js'))
+      )();
+      return new module.LibghosttyVtBackend(
+        sessionId,
+        profile,
+        options.libghosttyVt,
+      );
+    }
+  }
+}
diff --git a/src/replay/offlineReplay.ts b/src/replay/offlineReplay.ts
index e2ccec2..226dbc8 100644
--- a/src/replay/offlineReplay.ts
+++ b/src/replay/offlineReplay.ts
@@ -4,8 +4,13 @@ import { buildReplayInput, readEventLogRecords } from '../host/replay.js';
 import { ERROR_CODES, makeCliError } from '../protocol/errors.js';
 import type { EventRecord, SessionRecord } from '../protocol/schemas.js';
 import type { RendererBackend } from '../renderer/backend.js';
-import { GhosttyWebBackend } from '../renderer/ghosttyWeb/backend.js';
+import {
+  DEFAULT_RENDERER_NAME,
+  resolveRendererName,
+  type RendererName,
+} from '../renderer/names.js';
 import { resolveProfile } from '../renderer/profiles.js';
+import { createRendererBackend } from '../renderer/registry.js';
 import type { RenderProfileConfig, ReplayInput } from '../renderer/types.js';
 import { readManifestIfExists } from '../storage/manifests.js';
 import { eventLogPath, manifestPath } from '../storage/sessionPaths.js';
@@ -13,9 +18,10 @@ import { invariant } from '../util/assert.js';
 
 export interface OfflineReplayDeps {
   backendFactory?: (
+    rendererName: RendererName,
     sessionId: string,
     profile: RenderProfileConfig,
-  ) => RendererBackend;
+  ) => RendererBackend | Promise<RendererBackend>;
 }
 
 interface OfflineReplayContext {
@@ -51,22 +57,31 @@ function isEnoentError(error: unknown): error is Error & NodeError {
   );
 }
 
-function createBackend(
+async function createBackend(
+  rendererName: RendererName,
   sessionId: string,
   profile: RenderProfileConfig,
   deps?: OfflineReplayDeps,
-): RendererBackend {
+): Promise<RendererBackend> {
   const backendFactory =
     deps?.backendFactory ??
-    ((factorySessionId: string, factoryProfile: RenderProfileConfig) =>
-      new GhosttyWebBackend(factorySessionId, factoryProfile));
+    ((
+      factoryRendererName: RendererName,
+      factorySessionId: string,
+      factoryProfile: RenderProfileConfig,
+    ) =>
+      createRendererBackend(
+        factoryRendererName,
+        factorySessionId,
+        factoryProfile,
+      ));
 
   invariant(
     typeof backendFactory === 'function',
     'backendFactory must be a function when provided',
   );
 
-  return backendFactory(sessionId, profile);
+  return await backendFactory(rendererName, sessionId, profile);
 }
 
 async function readOfflineReplayInput(
@@ -106,6 +121,7 @@ export async function withOfflineReplayRenderer<T>(
     sessionDir: string;
     profileName?: string;
     targetSeq?: number;
+    rendererName?: RendererName;
   },
   run: (context: OfflineReplayContext) => Promise<T>,
   deps?: OfflineReplayDeps,
@@ -113,6 +129,9 @@ export async function withOfflineReplayRenderer<T>(
   invariant(typeof run === 'function', 'run must be a function');
   const sessionDir = assertAbsoluteSessionDir(options.sessionDir);
   const sessionId = getSessionId(sessionDir);
+  const rendererName = resolveRendererName(
+    options.rendererName ?? DEFAULT_RENDERER_NAME,
+  );
 
   const manifestFile = manifestPath(sessionDir);
   const manifest = await readManifestIfExists(manifestFile);
@@ -131,7 +150,7 @@ export async function withOfflineReplayRenderer<T>(
     });
   }
 
-  const backend = createBackend(sessionId, profile, deps);
+  const backend = await createBackend(rendererName, sessionId, profile, deps);
 
   try {
     const replayInput = await readOfflineReplayInput(
diff --git a/test/e2e/libghostty-vt-renderer.test.ts b/test/e2e/libghostty-vt-renderer.test.ts
new file mode 100644
index 0000000..b1a8dc0
--- /dev/null
+++ b/test/e2e/libghostty-vt-renderer.test.ts
@@ -0,0 +1,150 @@
+import { stat } from 'node:fs/promises';
+
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import {
+  cleanupHome,
+  createIsolatedHome,
+  DEFAULT_WAIT_TIMEOUT_MS,
+  fixtureCommand,
+  runCli,
+  runCliJson,
+  type SuccessEnvelope,
+} from './helpers.js';
+import type {
+  ScreenshotResult,
+  SnapshotResult,
+  WaitForRenderResult,
+} from '../../src/protocol/messages.js';
+
+let nativeAvailable = false;
+let nativeSkipReason = '';
+try {
+  await import('@coder/libghostty-vt-node');
+  nativeAvailable = true;
+} catch (error) {
+  nativeSkipReason = error instanceof Error ? error.message : String(error);
+}
+
+interface CreateResult {
+  sessionId: string;
+}
+
+interface SendKeysResult {
+  accepted: string[];
+  bytesWritten: number;
+  seq: number;
+}
+
+function testEnv(home: string): Record<string, string> {
+  return { AGENT_TTY_HOME: home };
+}
+
+const maybeIt = nativeAvailable ? it : it.skip;
+
+describe('libghostty-vt renderer e2e', { timeout: 120_000 }, () => {
+  let testHome = '';
+  let createdSessionIds: string[] = [];
+
+  beforeEach(async () => {
+    testHome = await createIsolatedHome();
+    createdSessionIds = [];
+  });
+
+  afterEach(async () => {
+    const env = testEnv(testHome);
+    for (const sessionId of createdSessionIds) {
+      runCli(['destroy', sessionId, '--force', '--json'], env);
+    }
+    await cleanupHome(testHome);
+  });
+
+  maybeIt(
+    nativeAvailable
+      ? 'captures semantic state through libghostty-vt and screenshots through fallback'
+      : `skips because @coder/libghostty-vt-node is unavailable: ${nativeSkipReason}`,
+    async () => {
+      const env = testEnv(testHome);
+      const createEnvelope = runCliJson<SuccessEnvelope<CreateResult>>(
+        ['create', '--', ...fixtureCommand('hello-prompt')],
+        env,
+      );
+      expect(createEnvelope.ok).toBe(true);
+      const sessionId = createEnvelope.result.sessionId;
+      createdSessionIds.push(sessionId);
+
+      const waitForReady = runCliJson<SuccessEnvelope<WaitForRenderResult>>(
+        [
+          '--renderer',
+          'libghostty-vt',
+          'wait',
+          sessionId,
+          '--text',
+          'READY>',
+          '--timeout',
+          String(DEFAULT_WAIT_TIMEOUT_MS),
+        ],
+        env,
+      );
+      expect(waitForReady.result.timedOut).toBe(false);
+      expect(waitForReady.result.matched).toBe(true);
+
+      const typeEnvelope = runCliJson<SuccessEnvelope<Record<string, never>>>(
+        ['type', sessionId, 'native hello'],
+        env,
+      );
+      expect(typeEnvelope.ok).toBe(true);
+
+      const enterEnvelope = runCliJson<SuccessEnvelope<SendKeysResult>>(
+        ['send-keys', sessionId, 'Enter'],
+        env,
+      );
+      expect(enterEnvelope.result.accepted).toEqual(['Enter']);
+
+      const waitForEcho = runCliJson<SuccessEnvelope<WaitForRenderResult>>(
+        [
+          '--renderer',
+          'libghostty-vt',
+          'wait',
+          sessionId,
+          '--text',
+          'ECHO: native hello',
+          '--timeout',
+          String(DEFAULT_WAIT_TIMEOUT_MS),
+        ],
+        env,
+      );
+      expect(waitForEcho.result.timedOut).toBe(false);
+      expect(waitForEcho.result.matched).toBe(true);
+
+      const snapshotEnvelope = runCliJson<SuccessEnvelope<SnapshotResult>>(
+        [
+          '--renderer',
+          'libghostty-vt',
+          'snapshot',
+          sessionId,
+          '--format',
+          'structured',
+        ],
+        env,
+      );
+      expect(snapshotEnvelope.result.format).toBe('structured');
+      if (snapshotEnvelope.result.format !== 'structured') {
+        throw new Error('expected structured snapshot');
+      }
+      expect(
+        snapshotEnvelope.result.visibleLines.some((line) =>
+          line.text.includes('ECHO: native hello'),
+        ),
+      ).toBe(true);
+
+      const screenshotEnvelope = runCliJson<SuccessEnvelope<ScreenshotResult>>(
+        ['--renderer', 'libghostty-vt', 'screenshot', sessionId],
+        env,
+      );
+      expect(screenshotEnvelope.result.rendererBackend).toBe('ghostty-web');
+      const pngStats = await stat(screenshotEnvelope.result.artifactPath);
+      expect(pngStats.size).toBeGreaterThan(0);
+    },
+  );
+});
diff --git a/test/integration/backend-selection.test.ts b/test/integration/backend-selection.test.ts
new file mode 100644
index 0000000..12e6735
--- /dev/null
+++ b/test/integration/backend-selection.test.ts
@@ -0,0 +1,121 @@
+import { mkdtemp, realpath, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import {
+  cleanupHome,
+  createSession,
+  destroySession,
+  runCli,
+} from '../helpers.js';
+
+interface FailureEnvelope {
+  ok: false;
+  error: {
+    code: string;
+    message: string;
+  };
+}
+
+describe('backend selection integration', () => {
+  let testHome = '';
+  let sessionId = '';
+
+  beforeEach(async () => {
+    // prettier-ignore
+    testHome = await realpath(await mkdtemp(join(tmpdir(), 'agent-tty-backend-selection-')));
+  });
+
+  afterEach(async () => {
+    destroySession(testHome, sessionId);
+    await cleanupHome(testHome);
+    sessionId = '';
+    testHome = '';
+  });
+
+  it('accepts --renderer ghostty-web without changing basic CLI behavior', () => {
+    const result = runCli(['--renderer', 'ghostty-web', 'doctor', '--json'], {
+      AGENT_TTY_HOME: testHome,
+    });
+
+    expect(result.status).toBe(0);
+    expect(result.stderr).toBe('');
+    expect(JSON.parse(result.stdout)).toMatchObject({ ok: true });
+  });
+
+  it('accepts AGENT_TTY_RENDERER=ghostty-web', () => {
+    const result = runCli(['doctor', '--json'], {
+      AGENT_TTY_HOME: testHome,
+      AGENT_TTY_RENDERER: 'ghostty-web',
+    });
+
+    expect(result.status).toBe(0);
+    expect(result.stderr).toBe('');
+    expect(JSON.parse(result.stdout)).toMatchObject({ ok: true });
+  });
+
+  it('honors config defaultRenderer during context resolution', async () => {
+    await writeFile(
+      join(testHome, 'config.json'),
+      `${JSON.stringify({ defaultRenderer: 'ghostty-web' })}\n`,
+      'utf8',
+    );
+
+    const result = runCli(['doctor', '--json'], {
+      AGENT_TTY_HOME: testHome,
+    });
+
+    expect(result.status).toBe(0);
+    expect(result.stderr).toBe('');
+    expect(JSON.parse(result.stdout)).toMatchObject({ ok: true });
+  });
+
+  it('rejects invalid renderer names before backend use', () => {
+    const result = runCli(
+      ['--renderer', 'not-a-renderer', 'doctor', '--json'],
+      { AGENT_TTY_HOME: testHome },
+    );
+
+    expect(result.status).not.toBe(0);
+    const envelope = JSON.parse(result.stdout) as FailureEnvelope;
+    expect(envelope.ok).toBe(false);
+    expect(envelope.error).toMatchObject({
+      code: 'INVALID_INPUT',
+      message: 'Renderer must be one of: ghostty-web, libghostty-vt.',
+    });
+  });
+
+  it('threads --renderer ghostty-web through live snapshot RPC paths', () => {
+    sessionId = createSession(testHome, [
+      '/bin/sh',
+      '-c',
+      'printf renderer-selection-ready; exec cat',
+    ]);
+
+    const result = runCli(
+      [
+        '--renderer',
+        'ghostty-web',
+        'snapshot',
+        sessionId,
+        '--format',
+        'structured',
+        '--json',
+      ],
+      { AGENT_TTY_HOME: testHome },
+      60_000,
+    );
+
+    expect(result.status).toBe(0);
+    expect(result.stderr).toBe('');
+    expect(JSON.parse(result.stdout)).toMatchObject({
+      ok: true,
+      result: {
+        format: 'structured',
+        sessionId,
+      },
+    });
+  });
+});
diff --git a/test/unit/cli/context.test.ts b/test/unit/cli/context.test.ts
index 08263e0..a991545 100644
--- a/test/unit/cli/context.test.ts
+++ b/test/unit/cli/context.test.ts
@@ -21,6 +21,7 @@ import {
   parseTimeoutMsOption,
   resolveCommandContext,
   resolveLogLevel,
+  resolveRendererDefault,
   setCommandContext,
 } from '../../../src/cli/context.js';
 import { ERROR_CODES } from '../../../src/protocol/errors.js';
@@ -140,6 +141,45 @@ describe('CLI context resolution', () => {
     ).resolves.toMatchObject({ profileDefault: undefined });
   });
 
+  it('resolves rendererDefault from flag, env, config, and default precedence', async () => {
+    mocks.loadConfigFile.mockResolvedValue({
+      defaultRenderer: 'libghostty-vt',
+    });
+
+    await expect(
+      resolveCommandContext(
+        { home: TEST_FLAG_HOME, renderer: 'ghostty-web' },
+        {},
+      ),
+    ).resolves.toMatchObject({ rendererDefault: 'ghostty-web' });
+    await expect(
+      resolveCommandContext(
+        { home: TEST_FLAG_HOME },
+        {
+          AGENT_TTY_HOME: TEST_ENV_HOME,
+          AGENT_TTY_RENDERER: 'ghostty-web',
+        },
+      ),
+    ).resolves.toMatchObject({ rendererDefault: 'ghostty-web' });
+    await expect(
+      resolveCommandContext({ home: TEST_FLAG_HOME }, {}),
+    ).resolves.toMatchObject({ rendererDefault: 'libghostty-vt' });
+
+    mocks.loadConfigFile.mockResolvedValue(null);
+    await expect(
+      resolveCommandContext({ home: TEST_FLAG_HOME }, {}),
+    ).resolves.toMatchObject({ rendererDefault: 'ghostty-web' });
+  });
+
+  it('rejects invalid renderer names', async () => {
+    await expect(
+      resolveCommandContext({ home: TEST_FLAG_HOME, renderer: 'canvas' }, {}),
+    ).rejects.toMatchObject({
+      code: ERROR_CODES.INVALID_INPUT,
+      message: 'Renderer must be one of: ghostty-web, libghostty-vt.',
+    });
+  });
+
   it('keeps resolving when the config file is missing', async () => {
     mocks.loadConfigFile.mockResolvedValue(null);
 
@@ -173,6 +213,7 @@ describe('CLI context resolution', () => {
       logLevel: 'info' as const,
       logger: createLogger('info', () => undefined),
       profileDefault: 'default-profile',
+      rendererDefault: 'ghostty-web',
       configFile: null,
     });
     setCommandContext(command, cachedContext);
@@ -202,6 +243,17 @@ describe('CLI context resolution', () => {
     );
   });
 
+  it('resolves and validates renderer names', () => {
+    expect(resolveRendererDefault()).toBe('ghostty-web');
+    expect(resolveRendererDefault('libghostty-vt')).toBe('libghostty-vt');
+    expect(() => resolveRendererDefault('canvas')).toThrow(
+      expect.objectContaining({
+        code: ERROR_CODES.INVALID_INPUT,
+        message: 'Renderer must be one of: ghostty-web, libghostty-vt.',
+      }),
+    );
+  });
+
   it('resolves and validates log levels', () => {
     expect(resolveLogLevel()).toBe('info');
     expect(resolveLogLevel('error')).toBe('error');
diff --git a/test/unit/commands/create.test.ts b/test/unit/commands/create.test.ts
index acb77e6..403693a 100644
--- a/test/unit/commands/create.test.ts
+++ b/test/unit/commands/create.test.ts
@@ -50,6 +50,7 @@ describe('create command', () => {
     logLevel: 'info',
     logger: createLogger('info', () => undefined),
     profileDefault: undefined,
+    rendererDefault: 'ghostty-web',
     configFile: null,
   } as const;
   const baseOptions = {
diff --git a/test/unit/commands/inspect.test.ts b/test/unit/commands/inspect.test.ts
index fefffb0..0ffab92 100644
--- a/test/unit/commands/inspect.test.ts
+++ b/test/unit/commands/inspect.test.ts
@@ -64,6 +64,7 @@ const TEST_CONTEXT = {
   logLevel: 'info',
   logger: createLogger('info', () => undefined),
   profileDefault: undefined,
+  rendererDefault: 'ghostty-web',
   configFile: null,
 } as const;
 
diff --git a/test/unit/commands/mark.test.ts b/test/unit/commands/mark.test.ts
index 7eca964..a1ca754 100644
--- a/test/unit/commands/mark.test.ts
+++ b/test/unit/commands/mark.test.ts
@@ -44,6 +44,7 @@ const TEST_CONTEXT = {
   logLevel: 'info',
   logger: createLogger('info', () => undefined),
   profileDefault: undefined,
+  rendererDefault: 'ghostty-web',
   configFile: null,
 } as const;
 
diff --git a/test/unit/commands/record-export.test.ts b/test/unit/commands/record-export.test.ts
index 3366be9..cb2c454 100644
--- a/test/unit/commands/record-export.test.ts
+++ b/test/unit/commands/record-export.test.ts
@@ -92,6 +92,7 @@ const TEST_CONTEXT = {
   logLevel: 'info',
   logger: createLogger('info', () => undefined),
   profileDefault: undefined,
+  rendererDefault: 'ghostty-web',
   configFile: null,
 } as const;
 
@@ -329,6 +330,7 @@ describe('record export command', () => {
       rows: 24,
       profileName: 'reference-dark',
       timingMode: 'accelerated',
+      rendererBackend: 'ghostty-web',
     });
     mocks.stat.mockResolvedValue({ size: webmBytes });
     mocks.readFile.mockResolvedValue(webmContent);
@@ -348,6 +350,7 @@ describe('record export command', () => {
         manifest: ReturnType<typeof createSessionRecord>;
         events: unknown[];
         outputPath: string;
+        rendererName?: string;
       },
     ];
     const [generateWebmExportArgs] = generateWebmExportCall;
@@ -374,6 +377,7 @@ describe('record export command', () => {
     expect(generateWebmExportArgs.outputPath).toBe(
       '/tmp/agent-tty/sessions/session-01/artifacts/recording-1-webm.webm',
     );
+    expect(generateWebmExportArgs.rendererName).toBe('ghostty-web');
     expect(mocks.writeTextFileAtomic).not.toHaveBeenCalled();
     expect(mocks.stat).toHaveBeenCalledWith(
       '/tmp/agent-tty/sessions/session-01/artifacts/recording-1-webm.webm',
@@ -404,6 +408,7 @@ describe('record export command', () => {
     );
     expect(artifactEntry.metadata.profileName).toBe('reference-dark');
     expect(artifactEntry.metadata.timingMode).toBe('accelerated');
+    expect(artifactEntry.metadata.rendererBackend).toBe('ghostty-web');
 
     expect(mocks.emitSuccess).toHaveBeenCalledTimes(1);
     const emitSuccessCall = mocks.emitSuccess.mock.calls[0] as [
@@ -433,6 +438,7 @@ describe('record export command', () => {
     expect(emitSuccessArgs.result.metadata.renderProfileHash).toBe(
       expectedRenderProfileHash,
     );
+    expect(emitSuccessArgs.result.metadata.rendererBackend).toBe('ghostty-web');
     expect(emitSuccessArgs.result.durationMs).toBe(1_500);
   });
 
@@ -447,6 +453,7 @@ describe('record export command', () => {
       rows: 24,
       profileName: 'reference-light',
       timingMode: 'accelerated',
+      rendererBackend: 'ghostty-web',
     });
     const webmBytes = 12_345;
     const webmContent = Buffer.alloc(webmBytes, 0x42);
@@ -506,6 +513,7 @@ describe('record export command', () => {
       rows: 24,
       profileName: 'reference-dark',
       timingMode: 'recorded',
+      rendererBackend: 'ghostty-web',
     });
     const webmBytes = 12_345;
     const webmContent = Buffer.alloc(webmBytes, 0x42);
@@ -538,6 +546,7 @@ describe('record export command', () => {
       rows: 24,
       profileName: 'reference-dark',
       timingMode: 'max-speed',
+      rendererBackend: 'ghostty-web',
     });
     const webmBytes = 12_345;
     const webmContent = Buffer.alloc(webmBytes, 0x42);
@@ -570,6 +579,7 @@ describe('record export command', () => {
       rows: 24,
       profileName: 'reference-dark',
       timingMode: 'accelerated',
+      rendererBackend: 'ghostty-web',
     });
     const webmBytes = 12_345;
     const webmContent = Buffer.alloc(webmBytes, 0x42);
@@ -615,6 +625,7 @@ describe('record export command', () => {
       rows: 24,
       profileName: 'reference-dark',
       timingMode: 'max-speed',
+      rendererBackend: 'ghostty-web',
     });
     const webmBytes = 12_345;
     const webmContent = Buffer.alloc(webmBytes, 0x42);
diff --git a/test/unit/commands/run.test.ts b/test/unit/commands/run.test.ts
index 69fc334..ccd2343 100644
--- a/test/unit/commands/run.test.ts
+++ b/test/unit/commands/run.test.ts
@@ -43,6 +43,7 @@ const TEST_CONTEXT = {
   logLevel: 'info',
   logger: createLogger('info', () => undefined),
   profileDefault: undefined,
+  rendererDefault: 'ghostty-web',
   configFile: null,
 } as const;
 
diff --git a/test/unit/commands/screenshot.test.ts b/test/unit/commands/screenshot.test.ts
index 3034c46..c28abc9 100644
--- a/test/unit/commands/screenshot.test.ts
+++ b/test/unit/commands/screenshot.test.ts
@@ -77,6 +77,7 @@ const TEST_CONTEXT = {
   logLevel: 'info',
   logger: createLogger('info', () => undefined),
   profileDefault: undefined,
+  rendererDefault: 'ghostty-web',
   configFile: null,
 } as const;
 const TEST_SCREENSHOT_SHA256 = 'a'.repeat(64);
@@ -222,7 +223,7 @@ describe('screenshot command', () => {
     expect(mocks.sendRpc).toHaveBeenCalledWith(
       '/tmp/agent-tty/sessions/session-01/rpc.sock',
       'screenshot',
-      { profile: 'reference-dark' },
+      { profile: 'reference-dark', rendererName: 'ghostty-web' },
     );
     expect(mocks.emitSuccess).toHaveBeenCalledWith({
       command: 'screenshot',
@@ -260,7 +261,11 @@ describe('screenshot command', () => {
     expect(mocks.sendRpc).toHaveBeenCalledWith(
       '/tmp/agent-tty/sessions/session-01/rpc.sock',
       'screenshot',
-      { profile: 'reference-dark', showCursor: true },
+      {
+        profile: 'reference-dark',
+        rendererName: 'ghostty-web',
+        showCursor: true,
+      },
     );
     expect(mocks.emitSuccess).toHaveBeenCalledWith(
       expect.objectContaining({
@@ -289,7 +294,7 @@ describe('screenshot command', () => {
     expect(mocks.sendRpc).toHaveBeenCalledWith(
       '/tmp/agent-tty/sessions/session-01/rpc.sock',
       'screenshot',
-      { profile: 'configured-profile' },
+      { profile: 'configured-profile', rendererName: 'ghostty-web' },
     );
   });
 
@@ -315,7 +320,7 @@ describe('screenshot command', () => {
     expect(mocks.sendRpc).toHaveBeenCalledWith(
       '/tmp/agent-tty/sessions/session-01/rpc.sock',
       'screenshot',
-      { profile: 'reference-light' },
+      { profile: 'reference-light', rendererName: 'ghostty-web' },
     );
     expect(mocks.emitSuccess).toHaveBeenCalledWith({
       command: 'screenshot',
@@ -354,6 +359,7 @@ describe('screenshot command', () => {
       {
         sessionDir: '/tmp/agent-tty/sessions/session-01',
         profileName: 'reference-dark',
+        rendererName: 'ghostty-web',
       },
       expect.any(Function),
     );
@@ -489,7 +495,7 @@ describe('screenshot command', () => {
     expect(mocks.sendRpc).toHaveBeenCalledWith(
       '/tmp/agent-tty/sessions/session-01/rpc.sock',
       'screenshot',
-      { profile: 'reference-dark' },
+      { profile: 'reference-dark', rendererName: 'ghostty-web' },
     );
     expect(mocks.withOfflineReplayRenderer).toHaveBeenCalledTimes(1);
     expect(mocks.emitSuccess).toHaveBeenCalledWith(
diff --git a/test/unit/commands/snapshot.test.ts b/test/unit/commands/snapshot.test.ts
index 3d956ae..133b6e8 100644
--- a/test/unit/commands/snapshot.test.ts
+++ b/test/unit/commands/snapshot.test.ts
@@ -68,6 +68,7 @@ const TEST_CONTEXT = {
   logLevel: 'info',
   logger: createLogger('info', () => undefined),
   profileDefault: undefined,
+  rendererDefault: 'ghostty-web',
   configFile: null,
 } as const;
 
@@ -222,7 +223,12 @@ describe('snapshot command', () => {
     expect(mocks.sendRpc).toHaveBeenCalledWith(
       '/tmp/agent-tty/sessions/session-01/rpc.sock',
       'snapshot',
-      { format: 'structured', includeScrollback: false, includeCells: false },
+      {
+        format: 'structured',
+        includeScrollback: false,
+        includeCells: false,
+        rendererName: 'ghostty-web',
+      },
     );
     expect(mocks.emitSuccess).toHaveBeenCalledWith({
       command: 'snapshot',
@@ -265,7 +271,12 @@ describe('snapshot command', () => {
     expect(mocks.sendRpc).toHaveBeenCalledWith(
       '/tmp/agent-tty/sessions/session-01/rpc.sock',
       'snapshot',
-      { format: 'text', includeScrollback: false, includeCells: false },
+      {
+        format: 'text',
+        includeScrollback: false,
+        includeCells: false,
+        rendererName: 'ghostty-web',
+      },
     );
     expect(mocks.emitSuccess).toHaveBeenCalledWith({
       command: 'snapshot',
@@ -312,6 +323,7 @@ describe('snapshot command', () => {
       format: 'structured',
       includeScrollback: true,
       includeCells: false,
+      rendererName: 'ghostty-web',
     });
     const emitted = getLastEmitSuccessPayload() as {
       lines: string[];
@@ -365,6 +377,7 @@ describe('snapshot command', () => {
         format: 'structured',
         includeScrollback: false,
         includeCells: true,
+        rendererName: 'ghostty-web',
       },
     );
     expect(mocks.emitSuccess).toHaveBeenCalledWith({
@@ -408,7 +421,12 @@ describe('snapshot command', () => {
     expect(mocks.sendRpc).toHaveBeenCalledWith(
       '/tmp/agent-tty/sessions/session-01/rpc.sock',
       'snapshot',
-      { format: 'text', includeScrollback: true, includeCells: false },
+      {
+        format: 'text',
+        includeScrollback: true,
+        includeCells: false,
+        rendererName: 'ghostty-web',
+      },
     );
     expect(mocks.emitSuccess).toHaveBeenCalledWith({
       command: 'snapshot',
@@ -443,7 +461,10 @@ describe('snapshot command', () => {
 
     expect(mocks.sendRpc).not.toHaveBeenCalled();
     expect(mocks.withOfflineReplayRenderer).toHaveBeenCalledWith(
-      { sessionDir: '/tmp/agent-tty/sessions/session-01' },
+      {
+        sessionDir: '/tmp/agent-tty/sessions/session-01',
+        rendererName: 'ghostty-web',
+      },
       expect.any(Function),
     );
     expect(mocks.ensureArtifactsDir).toHaveBeenCalledWith(
@@ -669,10 +690,18 @@ describe('snapshot command', () => {
     expect(mocks.sendRpc).toHaveBeenCalledWith(
       '/tmp/agent-tty/sessions/session-01/rpc.sock',
       'snapshot',
-      { format: 'text', includeScrollback: false, includeCells: false },
+      {
+        format: 'text',
+        includeScrollback: false,
+        includeCells: false,
+        rendererName: 'ghostty-web',
+      },
     );
     expect(mocks.withOfflineReplayRenderer).toHaveBeenCalledWith(
-      { sessionDir: '/tmp/agent-tty/sessions/session-01' },
+      {
+        sessionDir: '/tmp/agent-tty/sessions/session-01',
+        rendererName: 'ghostty-web',
+      },
       expect.any(Function),
     );
     expect(mocks.emitSuccess).toHaveBeenCalledWith({
diff --git a/test/unit/commands/type.test.ts b/test/unit/commands/type.test.ts
index 792e89b..3e3ea12 100644
--- a/test/unit/commands/type.test.ts
+++ b/test/unit/commands/type.test.ts
@@ -42,6 +42,7 @@ const TEST_CONTEXT = {
   logLevel: 'info',
   logger: createLogger('info', () => undefined),
   profileDefault: undefined,
+  rendererDefault: 'ghostty-web',
   configFile: null,
 } as const;
 
diff --git a/test/unit/commands/wait.test.ts b/test/unit/commands/wait.test.ts
index 2b0bb39..5a161ee 100644
--- a/test/unit/commands/wait.test.ts
+++ b/test/unit/commands/wait.test.ts
@@ -49,6 +49,7 @@ const TEST_CONTEXT = {
   logLevel: 'info',
   logger: createLogger('info', () => undefined),
   profileDefault: undefined,
+  rendererDefault: 'ghostty-web',
   configFile: null,
 } as const;
 
@@ -280,6 +281,7 @@ describe('wait command', () => {
         cursorRow: undefined,
         cursorCol: undefined,
         timeoutMs: undefined,
+        rendererName: 'ghostty-web',
       },
       0,
     );
@@ -378,6 +380,7 @@ describe('wait command', () => {
         cursorRow: undefined,
         cursorCol: undefined,
         timeoutMs: 600_000,
+        rendererName: 'ghostty-web',
       },
       605_000,
     );
@@ -410,6 +413,7 @@ describe('wait command', () => {
         cursorRow: undefined,
         cursorCol: undefined,
         timeoutMs: 600_000,
+        rendererName: 'ghostty-web',
       },
       605_000,
     );
@@ -445,6 +449,7 @@ describe('wait command', () => {
         cursorRow: 3,
         cursorCol: 4,
         timeoutMs: 600_000,
+        rendererName: 'ghostty-web',
       },
       605_000,
     );
@@ -479,11 +484,15 @@ describe('wait command', () => {
         cursorRow: undefined,
         cursorCol: undefined,
         timeoutMs: 600_000,
+        rendererName: 'ghostty-web',
       },
       605_000,
     );
     expect(mocks.withOfflineReplayRenderer).toHaveBeenCalledWith(
-      { sessionDir: '/tmp/agent-tty/sessions/session-01' },
+      {
+        sessionDir: '/tmp/agent-tty/sessions/session-01',
+        rendererName: 'ghostty-web',
+      },
       expect.any(Function),
     );
     expect(mocks.emitSuccess).toHaveBeenCalledWith({
diff --git a/test/unit/config/resolveConfig.test.ts b/test/unit/config/resolveConfig.test.ts
index 950ec0d..d676008 100644
--- a/test/unit/config/resolveConfig.test.ts
+++ b/test/unit/config/resolveConfig.test.ts
@@ -32,6 +32,7 @@ describe('loadConfigFile', () => {
     const config = {
       logLevel: 'debug',
       defaultProfile: 'reference-dark',
+      defaultRenderer: 'libghostty-vt',
       defaultShell: '/bin/bash',
       defaultTerm: 'xterm-256color',
       defaultCols: 120,
@@ -76,6 +77,9 @@ describe('ConfigFileSchema', () => {
   it('accepts supported edge cases and rejects invalid values', () => {
     expect(ConfigFileSchema.safeParse({ idleTimeoutMs: 0 }).success).toBe(true);
     expect(ConfigFileSchema.safeParse({ defaultCols: 1 }).success).toBe(true);
+    expect(
+      ConfigFileSchema.safeParse({ defaultRenderer: 'ghostty-web' }).success,
+    ).toBe(true);
     expect(ConfigFileSchema.safeParse({ defaultRows: 0 }).success).toBe(false);
     expect(ConfigFileSchema.safeParse({ idleTimeoutMs: -1 }).success).toBe(
       false,
diff --git a/test/unit/export/webm.test.ts b/test/unit/export/webm.test.ts
index 864c113..52bccd9 100644
--- a/test/unit/export/webm.test.ts
+++ b/test/unit/export/webm.test.ts
@@ -1,10 +1,14 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 
-import type { VideoCapableRendererBackend } from '../../../src/renderer/backend.js';
+import type {
+  VideoCapableRendererBackend,
+  VideoRecordingOptions,
+} from '../../../src/renderer/backend.js';
 import type {
   EventRecord,
   SessionRecord,
 } from '../../../src/protocol/schemas.js';
+import type { RenderProfileConfig } from '../../../src/renderer/types.js';
 
 const mocks = vi.hoisted(() => ({
   buildReplayInput: vi.fn(),
@@ -173,6 +177,7 @@ describe('generateWebmExport', () => {
     });
     const backendFactory = vi.fn(
       (
+        rendererName: 'ghostty-web' | 'libghostty-vt',
         sessionId: string,
         profile: { fontSize: number; name: string },
         videoOptions: {
@@ -183,6 +188,7 @@ describe('generateWebmExport', () => {
           };
         },
       ) => {
+        void rendererName;
         void sessionId;
         void profile;
         void videoOptions;
@@ -216,8 +222,14 @@ describe('generateWebmExport', () => {
       return;
     }
 
-    const [backendSessionId, backendProfile, videoOptions] = backendCall;
+    const [
+      backendRendererName,
+      backendSessionId,
+      backendProfile,
+      videoOptions,
+    ] = backendCall;
 
+    expect(backendRendererName).toBe('ghostty-web');
     expect(backendSessionId).toBe('session-01');
     expect(backendProfile).toMatchObject({
       fontSize: 16,
@@ -258,9 +270,52 @@ describe('generateWebmExport', () => {
       rows: 24,
       profileName: 'reference-dark',
       timingMode: 'accelerated',
+      rendererBackend: 'ghostty-web',
     });
   });
 
+  it('falls back to ghostty-web when libghostty-vt is requested', async () => {
+    const mockBackend = createMockBackend();
+    const backendFactory = vi.fn(
+      (
+        rendererName: 'ghostty-web' | 'libghostty-vt',
+        sessionId: string,
+        profile: RenderProfileConfig,
+        videoOptions: VideoRecordingOptions,
+      ) => {
+        void rendererName;
+        void sessionId;
+        void profile;
+        void videoOptions;
+        return mockBackend.backend;
+      },
+    );
+
+    const result = await generateWebmExport(
+      {
+        sessionId: 'session-01',
+        sessionDir: '/tmp/agent-tty/sessions/session-01',
+        manifest: createManifest(),
+        events: createEvents(),
+        outputPath: '/tmp/exports/recording-1-webm.webm',
+        rendererName: 'libghostty-vt',
+      },
+      { backendFactory },
+    );
+
+    const backendFactoryCall = backendFactory.mock.calls[0];
+    expect(backendFactoryCall).toBeDefined();
+    if (backendFactoryCall === undefined) {
+      throw new Error('expected backendFactory to be called');
+    }
+    const [rendererName, sessionId, profile, videoOptions] = backendFactoryCall;
+    expect(rendererName).toBe('ghostty-web');
+    expect(sessionId).toBe('session-01');
+    expect(profile).toMatchObject({ name: 'reference-dark' });
+    expect(videoOptions.outputDir).toContain('agent-tty-webm-');
+    expect(result.rendererBackend).toBe('ghostty-web');
+  });
+
   it('passes recorded timing options when timingMode is recorded', async () => {
     const mockBackend = createMockBackend();
 
diff --git a/test/unit/host/renderer.test.ts b/test/unit/host/renderer.test.ts
index 3a840e9..427e3e3 100644
--- a/test/unit/host/renderer.test.ts
+++ b/test/unit/host/renderer.test.ts
@@ -168,6 +168,7 @@ function getCreatedBackend(
 }
 
 type BackendFactory = (
+  rendererName: 'ghostty-web' | 'libghostty-vt',
   sessionId: string,
   profile: RenderProfileConfig,
 ) => RendererBackend;
@@ -211,8 +212,8 @@ describe('HostRendererManager', () => {
       return backend;
     });
 
-    const first = manager.getBackend(createProfile(), null);
-    const second = manager.getBackend(createProfile(), null);
+    const first = manager.getBackend('ghostty-web', createProfile(), null);
+    const second = manager.getBackend('ghostty-web', createProfile(), null);
 
     await flushAsyncQueue();
 
@@ -234,8 +235,16 @@ describe('HostRendererManager', () => {
       backendFactory,
     });
 
-    const firstBackend = await manager.getBackend(createProfile(), null);
-    const secondBackend = await manager.getBackend(createProfile(), null);
+    const firstBackend = await manager.getBackend(
+      'ghostty-web',
+      createProfile(),
+      null,
+    );
+    const secondBackend = await manager.getBackend(
+      'ghostty-web',
+      createProfile(),
+      null,
+    );
 
     expect(firstBackend).toBe(secondBackend);
     expect(backendFactory).toHaveBeenCalledTimes(1);
@@ -248,8 +257,13 @@ describe('HostRendererManager', () => {
       backendFactory,
     });
 
-    const firstBackend = await manager.getBackend(createProfile('dark'), null);
+    const firstBackend = await manager.getBackend(
+      'ghostty-web',
+      createProfile('dark'),
+      null,
+    );
     const secondBackend = await manager.getBackend(
+      'ghostty-web',
       createProfile('light'),
       null,
     );
@@ -260,6 +274,30 @@ describe('HostRendererManager', () => {
     expect(getCreatedBackend(backends, 1)).toBe(secondBackend);
   });
 
+  it('recreates the backend when the renderer name changes', async () => {
+    const manager = new HostRendererManager({
+      sessionId: 'session-01',
+      sessionDir,
+      backendFactory,
+    });
+
+    const firstBackend = await manager.getBackend(
+      'ghostty-web',
+      createProfile('dark'),
+      null,
+    );
+    const secondBackend = await manager.getBackend(
+      'libghostty-vt',
+      createProfile('dark'),
+      null,
+    );
+
+    expect(secondBackend).not.toBe(firstBackend);
+    expect(backendFactory).toHaveBeenCalledTimes(2);
+    expect(getCreatedBackend(backends, 0).disposeMock).toHaveBeenCalledTimes(1);
+    expect(getCreatedBackend(backends, 1)).toBe(secondBackend);
+  });
+
   it('skips replay when the replay target sequence is -1', async () => {
     const manager = new HostRendererManager({
       sessionId: 'session-01',
@@ -268,6 +306,7 @@ describe('HostRendererManager', () => {
     });
 
     await manager.getBackend(
+      'ghostty-web',
       createProfile(),
       createReplayInput({ events: [], targetSeq: -1 }),
     );
@@ -283,7 +322,7 @@ describe('HostRendererManager', () => {
     });
     const replayInput = createReplayInput();
 
-    await manager.getBackend(createProfile(), replayInput);
+    await manager.getBackend('ghostty-web', createProfile(), replayInput);
 
     expect(getCreatedBackend(backends, 0).replayToMock).toHaveBeenCalledTimes(
       1,
@@ -300,12 +339,20 @@ describe('HostRendererManager', () => {
       backendFactory,
     });
 
-    const firstBackend = await manager.getBackend(createProfile(), null);
+    const firstBackend = await manager.getBackend(
+      'ghostty-web',
+      createProfile(),
+      null,
+    );
     const crashedBackend = getCreatedBackend(backends, 0);
     expect(crashedBackend).toBe(firstBackend);
     crashedBackend.setBooted(false);
 
-    const secondBackend = await manager.getBackend(createProfile(), null);
+    const secondBackend = await manager.getBackend(
+      'ghostty-web',
+      createProfile(),
+      null,
+    );
 
     expect(secondBackend).not.toBe(firstBackend);
     expect(backendFactory).toHaveBeenCalledTimes(2);
@@ -328,12 +375,16 @@ describe('HostRendererManager', () => {
       return backend;
     });
 
-    await expect(manager.getBackend(createProfile(), null)).rejects.toThrow(
-      'boot failed',
-    );
+    await expect(
+      manager.getBackend('ghostty-web', createProfile(), null),
+    ).rejects.toThrow('boot failed');
     expect(getCreatedBackend(backends, 0).disposeMock).toHaveBeenCalledTimes(1);
 
-    const recoveredBackend = await manager.getBackend(createProfile(), null);
+    const recoveredBackend = await manager.getBackend(
+      'ghostty-web',
+      createProfile(),
+      null,
+    );
 
     expect(recoveredBackend).toBe(getCreatedBackend(backends, 1));
     expect(backendFactory).toHaveBeenCalledTimes(2);
@@ -346,7 +397,7 @@ describe('HostRendererManager', () => {
       backendFactory,
     });
 
-    await manager.getBackend(createProfile(), null);
+    await manager.getBackend('ghostty-web', createProfile(), null);
 
     await expect(manager.dispose()).resolves.toBeUndefined();
     await expect(manager.dispose()).resolves.toBeUndefined();
@@ -410,10 +461,7 @@ describe('HostRendererManager', () => {
         new HostRendererManager({
           sessionId: 'session-01',
           sessionDir,
-          backendFactory: null as unknown as (
-            sessionId: string,
-            profile: RenderProfileConfig,
-          ) => RendererBackend,
+          backendFactory: null as unknown as BackendFactory,
         }),
     ).toThrow('backendFactory must be a function');
   });
diff --git a/test/unit/renderer/libghosttyVtBackend.test.ts b/test/unit/renderer/libghosttyVtBackend.test.ts
new file mode 100644
index 0000000..9630eac
--- /dev/null
+++ b/test/unit/renderer/libghosttyVtBackend.test.ts
@@ -0,0 +1,376 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import type { RendererBackend } from '../../../src/renderer/backend.js';
+import { LibghosttyVtBackend } from '../../../src/renderer/libghosttyVt/backend.js';
+import type { LibghosttyVtNativeModule } from '../../../src/renderer/libghosttyVt/backend.js';
+import type {
+  RenderProfileConfig,
+  ReplayInput,
+  ReplayState,
+  ScreenshotResult,
+  SemanticSnapshot,
+} from '../../../src/renderer/types.js';
+import { createLogger } from '../../../src/util/logger.js';
+
+function createProfile(): RenderProfileConfig {
+  return {
+    name: 'reference-dark',
+    theme: 'dark',
+    fontFamily: 'monospace',
+    fontSize: 14,
+    cursorStyle: 'block',
+    backgroundColor: '#000000',
+    foregroundColor: '#ffffff',
+  };
+}
+
+function createReplayInput(overrides: Partial<ReplayInput> = {}): ReplayInput {
+  return {
+    sessionId: 'session-01',
+    initialCols: 10,
+    initialRows: 4,
+    targetSeq: 2,
+    events: [
+      {
+        seq: 0,
+        ts: '2026-03-20T12:00:00.000Z',
+        type: 'output',
+        payload: { data: 'hello' },
+      },
+      {
+        seq: 1,
+        ts: '2026-03-20T12:00:00.100Z',
+        type: 'resize',
+        payload: { cols: 12, rows: 5 },
+      },
+      {
+        seq: 2,
+        ts: '2026-03-20T12:00:00.200Z',
+        type: 'output',
+        payload: { data: ' world' },
+      },
+    ],
+    ...overrides,
+  };
+}
+
+function createNativeFixture(options: { visibleText?: string } = {}) {
+  let cols = 80;
+  let rows = 24;
+  const feed = vi.fn();
+  const resize = vi.fn((nextCols: number, nextRows: number) => {
+    cols = nextCols;
+    rows = nextRows;
+  });
+  const snapshot = vi.fn(() => ({
+    cols,
+    rows,
+    cursorRow: Math.min(1, rows - 1),
+    cursorCol: Math.min(2, cols - 1),
+    isAltScreen: true,
+    visibleLines: [
+      { row: 0, text: 'hello world' },
+      { row: 1, text: 'prompt>' },
+    ],
+    scrollbackLines: [{ row: 0, text: 'scrolled' }],
+    cells: [
+      {
+        row: 0,
+        col: 0,
+        text: 'h',
+        width: 1,
+        bold: true,
+        foreground: '#ffffff',
+        background: '#000000',
+      },
+      {
+        row: 0,
+        col: 1,
+        text: 'i',
+        width: 1,
+        italic: true,
+      },
+    ],
+  }));
+  const getVisibleText = vi.fn(
+    () => options.visibleText ?? 'hello world\nprompt>',
+  );
+  const dispose = vi.fn();
+  const terminal = { feed, resize, snapshot, getVisibleText, dispose };
+  const createTerminal = vi.fn(
+    (createOptions: { cols: number; rows: number }) => {
+      cols = createOptions.cols;
+      rows = createOptions.rows;
+      return terminal;
+    },
+  );
+  const module: LibghosttyVtNativeModule = {
+    createTerminal,
+    getNativeInfo: vi.fn(() => ({
+      packageVersion: '0.1.0-beta.0',
+      napiVersion: 10,
+      platform: 'linux',
+      arch: 'x64',
+    })),
+  };
+
+  return {
+    module,
+    terminal,
+    createTerminal,
+    feed,
+    resize,
+    snapshot,
+    getVisibleText,
+    dispose,
+  };
+}
+
+function createFallbackBackend(): RendererBackend & {
+  bootMock: ReturnType<typeof vi.fn>;
+  replayToMock: ReturnType<typeof vi.fn>;
+  screenshotMock: ReturnType<typeof vi.fn>;
+  disposeMock: ReturnType<typeof vi.fn>;
+} {
+  let booted = false;
+  const bootMock = vi.fn(() => {
+    booted = true;
+    return Promise.resolve();
+  });
+  const replayToMock = vi.fn(
+    (input: ReplayInput): Promise<ReplayState> =>
+      Promise.resolve({
+        lastSeq: input.targetSeq,
+        cols: input.initialCols,
+        rows: input.initialRows,
+        cursorRow: 0,
+        cursorCol: 0,
+      }),
+  );
+  const screenshotMock = vi.fn(
+    (outputPath: string): Promise<ScreenshotResult> =>
+      Promise.resolve({
+        sessionId: 'session-01',
+        capturedAtSeq: 2,
+        profileName: 'reference-dark',
+        cols: 12,
+        rows: 5,
+        artifactPath: outputPath,
+        pngSizeBytes: 123,
+        rendererBackend: 'ghostty-web',
+      }),
+  );
+  const disposeMock = vi.fn(() => {
+    booted = false;
+    return Promise.resolve();
+  });
+
+  return {
+    rendererBackend: 'ghostty-web',
+    get isBooted() {
+      return booted;
+    },
+    boot: bootMock,
+    bootMock,
+    replayTo: replayToMock,
+    replayToMock,
+    snapshot: vi.fn(
+      (): Promise<SemanticSnapshot> =>
+        Promise.resolve({
+          sessionId: 'session-01',
+          capturedAtSeq: 2,
+          cols: 12,
+          rows: 5,
+          cursorRow: 0,
+          cursorCol: 0,
+          isAltScreen: false,
+          visibleLines: [],
+        }),
+    ),
+    screenshot: screenshotMock,
+    screenshotMock,
+    getVisibleText: vi.fn().mockResolvedValue(''),
+    dispose: disposeMock,
+    disposeMock,
+  };
+}
+
+function createBackend(
+  fixture = createNativeFixture(),
+  options: Partial<ConstructorParameters<typeof LibghosttyVtBackend>[2]> = {},
+): LibghosttyVtBackend {
+  return new LibghosttyVtBackend('session-01', createProfile(), {
+    loadNative: () => Promise.resolve(fixture.module),
+    logger: createLogger('info', () => undefined),
+    ...options,
+  });
+}
+
+describe('LibghosttyVtBackend', () => {
+  it('does not call the native loader before boot', () => {
+    const loadNative = vi.fn();
+
+    new LibghosttyVtBackend('session-01', createProfile(), {
+      loadNative,
+      logger: createLogger('info', () => undefined),
+    });
+
+    expect(loadNative).not.toHaveBeenCalled();
+  });
+
+  it('boots native terminal with configured dimensions', async () => {
+    const fixture = createNativeFixture();
+    const backend = createBackend(fixture, {
+      initialCols: 100,
+      initialRows: 30,
+    });
+
+    await backend.boot();
+
+    expect(fixture.createTerminal).toHaveBeenCalledWith({
+      cols: 100,
+      rows: 30,
+    });
+    expect(backend.isBooted).toBe(true);
+  });
+
+  it('replays output and resize events into the native terminal', async () => {
+    const fixture = createNativeFixture();
+    const backend = createBackend(fixture);
+
+    await backend.boot();
+    const state = await backend.replayTo(createReplayInput());
+
+    expect(fixture.feed).toHaveBeenCalledWith('hello');
+    expect(fixture.feed).toHaveBeenCalledWith(' world');
+    expect(fixture.resize).toHaveBeenNthCalledWith(1, 10, 4);
+    expect(fixture.resize).toHaveBeenNthCalledWith(2, 12, 5);
+    expect(state).toEqual({
+      lastSeq: 2,
+      cols: 12,
+      rows: 5,
+      cursorRow: 1,
+      cursorCol: 2,
+    });
+  });
+
+  it('maps native snapshots into semantic snapshots', async () => {
+    const fixture = createNativeFixture();
+    const backend = createBackend(fixture);
+
+    await backend.boot();
+    await backend.replayTo(createReplayInput());
+
+    const snapshot = await backend.snapshot({
+      includeScrollback: true,
+      includeCells: true,
+    });
+
+    expect(fixture.snapshot).toHaveBeenLastCalledWith({
+      includeScrollback: true,
+      includeCells: true,
+    });
+    expect(snapshot).toMatchObject({
+      sessionId: 'session-01',
+      capturedAtSeq: 2,
+      cols: 12,
+      rows: 5,
+      cursorRow: 1,
+      cursorCol: 2,
+      isAltScreen: true,
+      visibleLines: [
+        { row: 0, text: 'hello world' },
+        { row: 1, text: 'prompt>' },
+      ],
+      scrollbackLines: [{ row: 0, text: 'scrolled' }],
+      cells: [
+        {
+          lineNumber: 0,
+          cells: [
+            {
+              char: 'h',
+              fg: '#ffffff',
+              bg: '#000000',
+              bold: true,
+            },
+            { char: 'i', italic: true },
+          ],
+        },
+      ],
+    });
+  });
+
+  it('delegates getVisibleText to the native terminal', async () => {
+    const fixture = createNativeFixture({ visibleText: 'delegated text' });
+    const backend = createBackend(fixture);
+
+    await backend.boot();
+
+    await expect(backend.getVisibleText()).resolves.toBe('delegated text');
+    expect(fixture.getVisibleText).toHaveBeenCalledTimes(1);
+  });
+
+  it('uses ghostty-web fallback for screenshots and preserves fallback metadata', async () => {
+    const fixture = createNativeFixture();
+    const fallback = createFallbackBackend();
+    const backend = createBackend(fixture, {
+      fallbackFactory: () => fallback,
+    });
+
+    await backend.boot();
+    const replayInput = createReplayInput();
+    await backend.replayTo(replayInput);
+
+    const result = await backend.screenshot('/tmp/screenshot.png', {
+      showCursor: true,
+    });
+
+    expect(fallback.bootMock).toHaveBeenCalledTimes(1);
+    expect(fallback.replayToMock).toHaveBeenCalledWith(replayInput);
+    expect(fallback.screenshotMock).toHaveBeenCalledWith(
+      '/tmp/screenshot.png',
+      {
+        showCursor: true,
+      },
+    );
+    expect(result.rendererBackend).toBe('ghostty-web');
+  });
+
+  it('disposes native and fallback resources idempotently', async () => {
+    const fixture = createNativeFixture();
+    const fallback = createFallbackBackend();
+    const backend = createBackend(fixture, {
+      fallbackFactory: () => fallback,
+    });
+
+    await backend.boot();
+    await backend.replayTo(createReplayInput());
+    await backend.screenshot('/tmp/screenshot.png');
+    await backend.dispose();
+    await backend.dispose();
+
+    expect(fixture.dispose).toHaveBeenCalledTimes(1);
+    expect(fallback.disposeMock).toHaveBeenCalledTimes(1);
+    expect(backend.isBooted).toBe(false);
+  });
+
+  it('wraps boot failures with an actionable message', async () => {
+    const backend = new LibghosttyVtBackend('session-01', createProfile(), {
+      loadNative: () => Promise.reject(new Error('native unavailable')),
+      logger: createLogger('info', () => undefined),
+    });
+
+    await expect(backend.boot()).rejects.toThrow(
+      /@coder\/libghostty-vt-node.*--renderer ghostty-web/u,
+    );
+  });
+
+  it('throws clearly when used after dispose', async () => {
+    const backend = createBackend();
+
+    await backend.boot();
+    await backend.dispose();
+
+    await expect(backend.getVisibleText()).rejects.toThrow(/after dispose/u);
+  });
+});
diff --git a/test/unit/renderer/registry.test.ts b/test/unit/renderer/registry.test.ts
new file mode 100644
index 0000000..4e114b8
--- /dev/null
+++ b/test/unit/renderer/registry.test.ts
@@ -0,0 +1,126 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import type { RendererBackend } from '../../../src/renderer/backend.js';
+import {
+  DEFAULT_RENDERER_NAME,
+  createRendererBackend,
+  resolveRendererName,
+} from '../../../src/renderer/index.js';
+import type {
+  RenderProfileConfig,
+  ReplayInput,
+  ReplayState,
+  ScreenshotResult,
+  SemanticSnapshot,
+} from '../../../src/renderer/types.js';
+
+function createProfile(): RenderProfileConfig {
+  return {
+    name: 'reference-dark',
+    theme: 'dark',
+    fontFamily: 'monospace',
+    fontSize: 14,
+    cursorStyle: 'block',
+    backgroundColor: '#000000',
+    foregroundColor: '#ffffff',
+  };
+}
+
+function createFakeBackend(rendererBackend: string): RendererBackend {
+  return {
+    rendererBackend,
+    isBooted: false,
+    boot: vi.fn().mockResolvedValue(undefined),
+    replayTo: vi.fn(
+      (input: ReplayInput): Promise<ReplayState> =>
+        Promise.resolve({
+          lastSeq: input.targetSeq,
+          cols: input.initialCols,
+          rows: input.initialRows,
+          cursorRow: 0,
+          cursorCol: 0,
+        }),
+    ),
+    snapshot: vi.fn(
+      (): Promise<SemanticSnapshot> =>
+        Promise.resolve({
+          sessionId: 'session-01',
+          capturedAtSeq: 0,
+          cols: 80,
+          rows: 24,
+          cursorRow: 0,
+          cursorCol: 0,
+          isAltScreen: false,
+          visibleLines: [],
+        }),
+    ),
+    screenshot: vi.fn(
+      (outputPath: string): Promise<ScreenshotResult> =>
+        Promise.resolve({
+          sessionId: 'session-01',
+          capturedAtSeq: 0,
+          profileName: 'reference-dark',
+          cols: 80,
+          rows: 24,
+          artifactPath: outputPath,
+          pngSizeBytes: 1,
+        }),
+    ),
+    getVisibleText: vi.fn().mockResolvedValue(''),
+    dispose: vi.fn().mockResolvedValue(undefined),
+  };
+}
+
+describe('renderer registry', () => {
+  it('resolves the default renderer name', () => {
+    expect(DEFAULT_RENDERER_NAME).toBe('ghostty-web');
+    expect(resolveRendererName(undefined)).toBe('ghostty-web');
+  });
+
+  it('accepts known renderer names and rejects unknown names', () => {
+    expect(resolveRendererName('ghostty-web')).toBe('ghostty-web');
+    expect(resolveRendererName('libghostty-vt')).toBe('libghostty-vt');
+    expect(() => resolveRendererName('canvas')).toThrow(
+      /Renderer must be one of/u,
+    );
+  });
+
+  it('does not load the native backend module for ghostty-web', async () => {
+    const loadLibghosttyVtBackend = vi.fn();
+
+    const backend = await createRendererBackend(
+      'ghostty-web',
+      'session-01',
+      createProfile(),
+      { loadLibghosttyVtBackend },
+    );
+
+    expect(backend.rendererBackend).toBe('ghostty-web');
+    expect(loadLibghosttyVtBackend).not.toHaveBeenCalled();
+  });
+
+  it('lazy-loads the native backend module for libghostty-vt only', async () => {
+    const fakeBackend = createFakeBackend('libghostty-vt');
+    const LibghosttyVtBackend = vi.fn(function FakeLibghosttyVtBackend() {
+      return fakeBackend;
+    });
+    const loadLibghosttyVtBackend = vi.fn().mockResolvedValue({
+      LibghosttyVtBackend,
+    });
+
+    const backend = await createRendererBackend(
+      'libghostty-vt',
+      'session-01',
+      createProfile(),
+      { loadLibghosttyVtBackend },
+    );
+
+    expect(loadLibghosttyVtBackend).toHaveBeenCalledTimes(1);
+    expect(LibghosttyVtBackend).toHaveBeenCalledWith(
+      'session-01',
+      expect.objectContaining({ name: 'reference-dark' }),
+      undefined,
+    );
+    expect(backend).toBe(fakeBackend);
+  });
+});
diff --git a/test/unit/replay/offlineReplay.test.ts b/test/unit/replay/offlineReplay.test.ts
index 61fa098..82424a2 100644
--- a/test/unit/replay/offlineReplay.test.ts
+++ b/test/unit/replay/offlineReplay.test.ts
@@ -217,7 +217,8 @@ describe('withOfflineReplayRenderer', () => {
         return Promise.resolve('captured');
       },
       {
-        backendFactory(factorySessionId, profile) {
+        backendFactory(rendererName, factorySessionId, profile) {
+          expect(rendererName).toBe('ghostty-web');
           expect(factorySessionId).toBe(sessionId);
           expect(profile.name).toBe('reference-dark');
           return backend;
@@ -232,6 +233,24 @@ describe('withOfflineReplayRenderer', () => {
     expect(backend.disposed).toBe(true);
   });
 
+  it('passes the selected renderer name to the backend factory', async () => {
+    const { sessionDir, sessionId } = await createSessionFixture();
+    const backend = createMockBackend();
+
+    await withOfflineReplayRenderer(
+      { sessionDir, rendererName: 'libghostty-vt' },
+      () => Promise.resolve(undefined),
+      {
+        backendFactory(rendererName, factorySessionId, profile) {
+          expect(rendererName).toBe('libghostty-vt');
+          expect(factorySessionId).toBe(sessionId);
+          expect(profile.name).toBe('reference-dark');
+          return backend;
+        },
+      },
+    );
+  });
+
   it('rebuilds replay input that matches the expected event sequence from the event log', async () => {
     const expectedEvents: EventRecord[] = [
       {