diff --git a/CLAUDE.md b/CLAUDE.md
index 0ce48ec..1a09ab9 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -5,7 +5,7 @@
 
 ## 開発進捗
 
-最新: PLAN_02 Step 2（リモート実行ツール tias-remote．Newton・Archimedes の空き GPU を自動選択）完了．次は Step 3（データセット集計）
+最新: PLAN_02 Step 3（データセット集計・ややあり込み／除外の切り替え）完了．次は Step 4（学習パイプライン最小版）
 ※ 本欄は**最新ステップ 1 行のみ上書き更新**．詳細な進捗履歴（動機・設計判断・失敗パターン）は [docs/PROGRESS.md](docs/PROGRESS.md) に追記する．運用ルールは `.claude/rules/progress-log.md` を参照（該当ファイル編集時に自動ロードされる）．
 
 ## 必須ルール（コード実装時）
@@ -99,3 +99,4 @@
 ### 06_TEST（テスト）
 
 - データセット構成調査: docs/06_TEST/TEST_01_データセット構成調査.md
+- データセット集計結果: docs/06_TEST/TEST_02_データセット集計結果.md
diff --git "a/docs/02_ENV/ENV_04_\351\226\213\347\231\272\343\202\263\343\203\236\343\203\263\343\203\211.md" "b/docs/02_ENV/ENV_04_\351\226\213\347\231\272\343\202\263\343\203\236\343\203\263\343\203\211.md"
index f70fdcc..3c8c94e 100644
--- "a/docs/02_ENV/ENV_04_\351\226\213\347\231\272\343\202\263\343\203\236\343\203\263\343\203\211.md"
+++ "b/docs/02_ENV/ENV_04_\351\226\213\347\231\272\343\202\263\343\203\236\343\203\263\343\203\211.md"
@@ -21,6 +21,17 @@
 | 合成データの生成 | `uv run python scripts/make_synthetic_dataset.py` | 出力は `data/synthetic/`（`images/<label>_<severity>/` と `manifest.csv`）．既定は 1 ディレクトリ 10 枚・seed 0 |
 | 合成データの作り直し | `uv run python scripts/make_synthetic_dataset.py --overwrite` | 目印ファイル `.synthetic_dataset` がある出力先だけを削除して作り直す（実データの誤削除を防ぐため） |
 | 枚数・seed の指定 | `uv run python scripts/make_synthetic_dataset.py --per-dir 50 --seed 1` | 出力先は `--out` で変更できる |
+| manifest の生成 | `uv run tias-dataset build-manifest --config <設定>` | `images/` を走査して `manifest.csv` を書く．既存があれば `--overwrite` が必要 |
+| データセットの集計 | `uv run tias-dataset survey --config <設定>` | `runs/<実験ID>/` に集計値だけを書く．最後に実験 ID を出力する（[SPEC_01](../04_SPEC/SPEC_01_アーキテクチャ設計.md)「データセット集計の出力」） |
+
+**実データ（サーバ上）での実行例**（GPU を使わないので `--cpu`）:
+
+```bash
+uv run tias-remote run --name manifest --cpu --server Newton -- tias-dataset build-manifest --config configs/newton.yaml
+uv run tias-remote run --name survey --cpu --server Newton -- tias-dataset survey --config configs/newton.yaml
+uv run tias-remote logs survey          # 最後の行に実験 ID が出る
+uv run tias-remote pull <実験ID>          # 集計値と図だけが手元の runs/ に届く
+```
 
 設定ファイルは `configs/synthetic.yaml`（手元の合成データ）と `configs/newton.yaml`（サーバの実データ）．環境変数 `TIAS_DATA_ROOT` を設定すると `data.root` より優先される．
 
@@ -37,6 +48,7 @@
 | ジョブを起動（GPU 自動選択） | `uv run tias-remote run --name exp1 -- python scripts/xxx.py` |
 | GPU を指定して起動 | `uv run tias-remote run --name exp2 --server Newton --gpu 1 -- python ...` |
 | 選ばれる GPU だけ確かめる | `uv run tias-remote run --name exp1 --dry-run -- python ...` |
+| GPU を使わないジョブ | `uv run tias-remote run --name job --cpu [--server Newton] -- ...`（GPU の空きを待たない．`CUDA_VISIBLE_DEVICES` は空） |
 | ログの末尾・追従 | `uv run tias-remote logs exp1`・`uv run tias-remote logs exp1 -f` |
 | ジョブを止める | `uv run tias-remote kill exp1` |
 | 実験結果を持ち帰る | `uv run tias-remote pull <実験ID>`（重みも要るときは `--with-checkpoints`） |
@@ -79,5 +91,4 @@
 
 実装した時点で本ファイルに追記する．
 
-- データセットの集計（サーバ上で実行．枚数・患者数・クラス分布・破損チェック）
 - 学習・評価
diff --git "a/docs/03_PLAN/PLAN_02_\351\226\213\347\231\272\343\202\271\343\203\206\343\203\203\343\203\227.md" "b/docs/03_PLAN/PLAN_02_\351\226\213\347\231\272\343\202\271\343\203\206\343\203\203\343\203\227.md"
index d7338de..eba8393 100644
--- "a/docs/03_PLAN/PLAN_02_\351\226\213\347\231\272\343\202\271\343\203\206\343\203\203\343\203\227.md"
+++ "b/docs/03_PLAN/PLAN_02_\351\226\213\347\231\272\343\202\271\343\203\206\343\203\203\343\203\227.md"
@@ -8,7 +8,7 @@
 | --- | --- | --- |
 | 1 | 基盤: 設定スキーマ・合成データ生成・manifest 読み込み・患者単位分割 ✅ 完了 | なし（手元で完結） |
 | 2 | リモート実行ツール（送信・実行・回収・GPU 確認，回収ホワイトリスト）✅ 完了（Newton・Archimedes の 2 サーバ対応） | Step 1 |
-| 3 | データセット集計（実データの素性把握） | **臨床データのコピー完了**・倫理確認 |
+| 3 | データセット集計（実データの素性把握）✅ 完了（結果は [TEST_02](../06_TEST/TEST_02_データセット集計結果.md)） | **臨床データのコピー完了**・倫理確認 |
 | 4 | 学習パイプライン最小版（ConvNeXt-Tiny を 1 本通す） | Step 2・3 |
 | 5 | 評価・レポート生成（指標・混同行列・`runs/` 出力） | Step 4 |
 | 6 | ベースライン比較（TIASjudge のルールベース）※ 後回し | Step 5 |
@@ -31,9 +31,10 @@
 
 ## Step 3: データセット集計 (Dataset Survey)
 
-- **成果物**: データセット集計コマンド，`scripts/build_manifest.py`，集計レポート（`docs/06_TEST/` に記録）
-- **完了条件**: 枚数・患者数・クラス分布・画像サイズ分布・破損件数が数値で判明し，[SPEC_01](../04_SPEC/SPEC_01_アーキテクチャ設計.md)・[SPEC_02](../04_SPEC/SPEC_02_学習・評価仕様.md)の未確定事項（マスク外領域の扱い・入力解像度・患者 ID の追跡可否・ラベルの保存形式）が確定する
-- **前提**: 研究室 PC → サーバのデータコピーと，倫理審査・データ利用許諾の確認が済んでいること
+- **成果物**: `tias-dataset build-manifest`・`tias-dataset survey`（[SPEC_01](../04_SPEC/SPEC_01_アーキテクチャ設計.md)「データセット集計の出力」），設定 `data.severities` による「ややあり込み / 除外」の切り替えと，クラス × 程度での層化分割（[SPEC_02](../04_SPEC/SPEC_02_学習・評価仕様.md)「程度（ややあり）の扱い」），集計レポート（`docs/06_TEST/` に記録）
+- **完了条件**: 両サーバで manifest を生成し，実データの集計（件数・サイズ・破損・舌領域の割合・**クラス × 程度ごとの Lab 色**）が手元に集計値だけで届く．「ややあり」の色が淡紅と同じクラスの「あり」のどちらに近いかが数値（ΔE）で分かる
+- **背景**: 「ややあり」は臨床上は淡紅（正常）と判断されることが多い境界例であり，入れる場合と入れない場合の両方で実験する（2026-09-27 ユーザー判断）
+- **前提**: 研究室 PC → サーバのデータコピー（両サーバとも完了済み）
 
 ## Step 4: 学習パイプライン最小版 (Minimal Training)
 
diff --git "a/docs/04_SPEC/SPEC_01_\343\202\242\343\203\274\343\202\255\343\203\206\343\202\257\343\203\201\343\203\243\350\250\255\350\250\210.md" "b/docs/04_SPEC/SPEC_01_\343\202\242\343\203\274\343\202\255\343\203\206\343\202\257\343\203\201\343\203\243\350\250\255\350\250\210.md"
index f2d9dd8..bb65820 100644
--- "a/docs/04_SPEC/SPEC_01_\343\202\242\343\203\274\343\202\255\343\203\206\343\202\257\343\203\201\343\203\243\350\250\255\350\250\210.md"
+++ "b/docs/04_SPEC/SPEC_01_\343\202\242\343\203\274\343\202\255\343\203\206\343\202\257\343\203\201\343\203\243\350\250\255\350\250\210.md"
@@ -84,6 +84,7 @@
 | --- | --- | --- |
 | `data.root` | データのルート（`images/` と manifest を含む）．`~` を展開する．相対パスはカレントディレクトリ基準 | なし（必須） |
 | `data.manifest` | manifest のパス．相対パスは `data.root` 基準 | `manifest.csv` |
+| `data.severities` | 学習・評価に使う程度（`strong`・`mild`・`normal` の部分集合）．空・重複・未知の値は不可．**分割の後に適用する**（[SPEC_02](SPEC_02_学習・評価仕様.md)「程度（ややあり）の扱い」） | `[strong, mild, normal]` |
 | `split.seed` | 分割の seed | 42 |
 | `split.val_ratio`・`split.test_ratio` | 単一分割の比率．各 0 より大きく，合計 1 未満 | 0.15・0.15 |
 | `split.n_folds` | 交差検証の fold 数（2 以上） | 5 |
@@ -116,11 +117,14 @@
 ├── log.txt
 ├── figures/               # 図専用（学習曲線・混同行列等）．症例画像は書き込まない
 │   └── confusion_matrix.png
+├── dataset_summary.json   # データセット集計の結果（集計値のみ．データセット集計の実行時）
 ├── split.json             # 分割結果（患者 ID を含む．回収しない）
 └── checkpoints/best.pt
 ```
 
-実験 ID の書式: `YYYYmmdd-HHMMSS_<設定ファイル名>_<git短縮ハッシュ>`
+実験 ID の書式: `YYYYmmdd-HHMMSS_<名前>_<git短縮ハッシュ>`（`<名前>` は学習なら設定ファイル名，データセット集計なら `survey`）
+
+- サーバには `.git` を送らないため，git のハッシュは手元で求めて `tias-remote run` が環境変数 `TIAS_GIT_COMMIT` で渡す（[SPEC_03](SPEC_03_リモート実行仕様.md)）．未コミットの変更（**未追跡ファイルを含む**．`git status --porcelain` が空でない）があるときは末尾に `-dirty` が付く．値は英数字で始まり英数字・`_`・`-` の 64 文字以内でなければ拒否する．環境変数が無い場合（手元での直接実行等）は `nogit` とする
 
 - **`figures/` には図だけを置き，症例画像（舌画像そのもの・切り出し・誤分類例の画像）を書き込まない**．回収ホワイトリストが `figures/*.png` を回収対象にしているため
 - 患者 ID・画像ファイル名を含む出力（分割結果・個票の予測）は上記の回収対象外の名前で保存する
@@ -131,7 +135,7 @@
 
 | 回収する（`runs/<実験ID>/` 配下） | 回収しない |
 | --- | --- |
-| `config.yaml`・`history.csv`・`metrics.json`・`confusion_matrix.csv`・`log.txt` | 上記以外のすべて（`split.json`・個票の予測・画像・manifest 等） |
+| `config.yaml`・`history.csv`・`metrics.json`・`confusion_matrix.csv`・`log.txt`・`dataset_summary.json` | 上記以外のすべて（`split.json`・個票の予測・画像・manifest 等） |
 | `figures/*.png` | `figures/` 以外にある `*.png` |
 | `checkpoints/*.pt`（**明示的に指定したときのみ**） | 指定が無いときの `checkpoints/` |
 
@@ -143,9 +147,30 @@
 
 | コマンド | 役割 | 実行場所 |
 | --- | --- | --- |
-| データセット集計 | 枚数・患者数・クラス分布・画像サイズ・破損チェック | サーバ（結果の要約のみ手元へ） |
+| `tias-dataset build-manifest` | `images/` を走査して `manifest.csv` を書き出す（既存があれば `--overwrite` が必要） | サーバ |
+| `tias-dataset survey` | データセットを集計して `runs/<実験ID>/` に集計値だけを書き出す（下記） | サーバ（結果の要約のみ手元へ） |
 | 学習 | 設定 YAML を受け取って学習する | サーバ |
 | 評価 | 学習済み run の評価・レポート生成 | サーバ |
 | リモート実行 | コード送信・ジョブ実行・結果回収・GPU 空き確認（複数サーバ．[SPEC_03](SPEC_03_リモート実行仕様.md)） | 手元 |
 
 コマンド名は実装時に確定し，[ENV_04 開発コマンド](../02_ENV/ENV_04_開発コマンド.md)に記載する．
+
+### データセット集計の出力 (Dataset Survey Output)
+
+`tias-dataset survey` は manifest と画像を読み，**集計値だけ**を `runs/<実験ID>/dataset_summary.json` と `runs/<実験ID>/figures/` に書き出す．**画像単位の値・患者 ID・ファイル名は出力しない**（ログも同様）．集計の単位は `<label>_<severity>` の 9 グループと，クラス（5）・全体．
+
+| 項目 | 内容 |
+| --- | --- |
+| 件数 | グループ・クラス・程度ごとの画像数と患者数．条件ごと（`data.severities` の 2 条件）の件数 |
+| 読み込み | 読めなかった画像の件数，RGB 以外のモード・アルファチャンネル付きの件数 |
+| サイズ | 幅・高さの最小・最大・平均・中央値 |
+| 舌領域の割合 | 画像に占める舌領域（背景でない画素）の割合の最小・平均・最大 |
+| **舌領域の色（Lab）** | 画像ごとに舌領域の L\*・a\*・b\* の平均を求め，グループごとにその平均・標準偏差・中央値・10/90 パーセンタイルを出す |
+| **グループ間の色差** | グループ平均どうしの色差 ΔE（CIE76）．特に各 `mild` グループについて「淡紅（`light_red_normal`）との ΔE」と「同じクラスの `strong` との ΔE」を並べる |
+| 分割の確認 | 既定の設定で分割したときの，各分割・グループの件数（患者 ID は出さない） |
+
+- **背景の定義**: RGB がすべて 0 の画素を背景（マスク外）とし，それ以外を舌領域とする（[TEST_01](../06_TEST/TEST_01_データセット構成調査.md)．マスク外は黒 (0,0,0)）
+- **Lab の計算**: sRGB（ガンマ補正を外して線形化）→ XYZ（D65）→ CIE L\*a\*b\*（D65 白色点）．新しい依存を増やさず NumPy で計算する．画像の平均 Lab は，**画素ごとに Lab へ変換してから舌領域で平均する**（平均 RGB を変換するのではない）
+- RGBA 等のアルファ付き画像は「RGB 以外のモード」と「アルファ付き」の両方に数え，RGB に変換してから測る
+- **図**（`figures/`）: グループごとの L\*・a\*・b\* の分布（箱ひげ図等）．**画像そのもの・画像の切り出しは描かない**
+- 読めない画像があっても集計は止めず，件数として報告する（集計は現状把握のためであり，学習時の fail fast とは目的が異なる）．ただし manifest の検証エラーは従来どおり停止する
diff --git "a/docs/04_SPEC/SPEC_02_\345\255\246\347\277\222\343\203\273\350\251\225\344\276\241\344\273\225\346\247\230.md" "b/docs/04_SPEC/SPEC_02_\345\255\246\347\277\222\343\203\273\350\251\225\344\276\241\344\273\225\346\247\230.md"
index 7bf7771..9f1147b 100644
--- "a/docs/04_SPEC/SPEC_02_\345\255\246\347\277\222\343\203\273\350\251\225\344\276\241\344\273\225\346\247\230.md"
+++ "b/docs/04_SPEC/SPEC_02_\345\255\246\347\277\222\343\203\273\350\251\225\344\276\241\344\273\225\346\247\230.md"
@@ -43,13 +43,47 @@
 
 - 分割は `patient_id` と seed から決定的に生成し，`config.yaml` に記録する
 - **test セットはモデル選択に使わない**（val で選び，test は最後に一度だけ見る）
-- 層化はクラス（5 分類）で行う．`severity` は層化の条件に含めない（分割が細分化されすぎるため）が，分割後に `severity` の偏りを確認する
-- **実装方式**: 1 患者は 1 つの label しか持たない（manifest の検証で保証）ため，患者の一覧をクラスで層化して分ければ「患者単位」と「クラス層化」が同時に成り立つ
-  - 単一分割: クラスごとに患者を seed で並べ替え，「患者数 × 比率」の四捨五入で test・val の人数を取り，残りを train とする．train に患者が残らないクラスがあれば停止する
-  - K-fold: 患者の一覧に scikit-learn の `StratifiedKFold`（shuffle あり・seed 指定）を使う．評価側を `held_out` と呼ぶ（fold 内でさらに val を取るかは Step 4・5 で決める）．患者数が fold 数に満たないクラスがあれば停止する
+- **層化は「クラス × 程度」（`<label>_<severity>` の 9 グループ）で行う**．「ややあり除外」の条件で mild を抜いた後も，各分割のクラス比が保たれるようにするため（下記「程度（ややあり）の扱い」）．最小のグループは 51 枚で，比率 0.15 なら各分割に 8 枚程度入る
+  - 患者の層化グループは，その患者の `label` と `severity` で決める．同じ患者に複数の `severity` がある場合（将来の複数枚）は，最も強いもの（`strong` > `mild` > `normal`）を使う
+- 分割後にグループごとの件数を記録し，偏りを確認する
+- **実装方式**: 1 患者は 1 つの label しか持たない（manifest の検証で保証）ため，患者の一覧を層化グループで分ければ「患者単位」と「層化」が同時に成り立つ
+  - 単一分割: 層化グループごとに患者を seed で並べ替え，「患者数 × 比率」の四捨五入で test・val の人数を取り，残りを train とする．train に患者が残らないグループがあれば停止する
+  - K-fold: 患者の一覧に scikit-learn の `StratifiedKFold`（shuffle あり・seed 指定．層化ラベルは層化グループ）を使う．評価側を `held_out` と呼ぶ（fold 内でさらに val を取るかは Step 4・5 で決める）．患者数が fold 数に満たないグループがあれば停止する
   - どちらも最初に患者 ID を並べ替えるため，manifest の行順に依存しない
 - 分割結果（各分割の患者 ID）は**個票に当たるため手元へ回収しない**（サーバ上の `runs/` にのみ保存する．[SPEC_01](SPEC_01_アーキテクチャ設計.md)「回収ホワイトリスト」）
 
+## 程度（ややあり）の扱い (Severity Handling)
+
+**「ややあり」（`mild`）は，臨床上は淡紅（正常）と判断されることが多い境界例である**（2026-09-27 ユーザー確認）．学習に入れるか否かで結果が変わりうるため，**入れる場合と入れない場合の両方で実験する**．
+
+### 実験条件 (Conditions)
+
+設定 `data.severities`（[SPEC_01](SPEC_01_アーキテクチャ設計.md)「設定ファイル」）で使う程度を選ぶ．
+
+| 条件 | `data.severities` | 使う画像 | 枚数 |
+| --- | --- | --- | --- |
+| ややあり込み | `[strong, mild, normal]`（既定） | すべて | 1085 |
+| ややあり除外 | `[strong, normal]` | 「あり」と淡紅（正常） | 754 |
+
+- どちらの条件でも `label` は元のまま（5 クラス）．「ややあり」を淡紅に付け替える扱いは行わない
+- 「ややあり除外」でも 5 クラスすべてが残る（淡紅は `normal` のみ，他の 4 クラスは `strong` が残るため）
+
+### 分割との関係 (Split)
+
+- **分割は `data.severities` に関わらず，manifest 全体（1085 枚）で 1 回だけ行う**．条件ごとの除外は，分割の**後**に各分割（train / val / test）から該当する画像を取り除いて適用する
+- これにより，「ややあり除外」の各分割は「ややあり込み」の各分割の部分集合になり，**2 つの条件のモデルを同じ患者の test で比較できる**（条件ごとに分割し直すと test の患者が入れ替わり，差が条件によるものか分割によるものか切り分けられない）
+- 同じ seed なら，どちらの条件でも同じ分割結果になる
+
+### 評価 (Evaluation)
+
+| 評価 | 対象 | 目的 |
+| --- | --- | --- |
+| 条件間の比較 | test のうち `strong` と `normal`（両条件に共通する部分） | 同じデータで 2 つの条件のモデルを比べる |
+| ややあり込みモデルの層別評価 | test 全体と，`mild` の部分 | 境界例でどれだけ誤るか（「評価指標」の層別評価） |
+| **ややあり除外モデルに mild を推論させる** | test のうち `mild` | mild の画像が **淡紅と予測される割合**と**元のクラスと予測される割合**を出す．臨床で淡紅と判断されやすいという知見がデータ上でも成り立つかを確かめる |
+
+- `mild` の画像に対して淡紅と予測することを「誤り」と断定しない．上表の割合として報告し，解釈は人間が行う
+
 ## クラス不均衡 (Class Imbalance)
 
 実データのクラス分布は最大 / 最小 = 380 / 104 ≒ **3.7 倍**（[TEST_01](../06_TEST/TEST_01_データセット構成調査.md)）．中程度の不均衡であり，初回は対策を入れずに素の結果を見る．混同行列でどのクラスが落ちているかを確認してから，クラス重み付き損失等を**独立した実験**として追加し，効果を切り分けて評価する．
@@ -84,5 +118,6 @@
 - 舌色 5 分類を順序尺度として扱えるか（quadratic weighted kappa の採用可否）
 - 入力解像度 224 で足りるか（元画像は平均 675×614 で，約 1/3 に縮小することになる）
 - 黒背景が面積の大半を占めるため，正規化・統計を画像全体で取るか舌領域内のみで取るか
+- 「ややあり」を含めるか否かの結論（両条件の実験結果を見て決める）
 - ルールベース診断の取り込み方
 - 医師ラベルの評価者間一致率（分かれば性能の上限の目安になる）
diff --git "a/docs/04_SPEC/SPEC_03_\343\203\252\343\203\242\343\203\274\343\203\210\345\256\237\350\241\214\344\273\225\346\247\230.md" "b/docs/04_SPEC/SPEC_03_\343\203\252\343\203\242\343\203\274\343\203\210\345\256\237\350\241\214\344\273\225\346\247\230.md"
index 47ef57d..39e6b3c 100644
--- "a/docs/04_SPEC/SPEC_03_\343\203\252\343\203\242\343\203\274\343\203\210\345\256\237\350\241\214\344\273\225\346\247\230.md"
+++ "b/docs/04_SPEC/SPEC_03_\343\203\252\343\203\242\343\203\274\343\203\210\345\256\237\350\241\214\344\273\225\346\247\230.md"
@@ -152,7 +152,7 @@
 | --- | --- |
 | `gpus [--observe SEC]` | 全サーバの GPU 一覧（状態・使い方の型・利用者）と，`run` が選ぶ GPU を表示する |
 | `push [--server NAME]` | コードを送る．省略時は接続できる全サーバ |
-| `run --name NAME [--server S] [--gpu I] [--force] [--no-data] [--no-push] [--observe SEC] [--env K=V ...] -- CMD...` | GPU を選び，そのサーバへコードを送り（`--no-push` で省略），tmux でジョブを起動する |
+| `run --name NAME [--server S] [--gpu I \| --cpu] [--force] [--no-data] [--no-push] [--observe SEC] [--env K=V ...] -- CMD...` | GPU を選び，そのサーバへコードを送り（`--no-push` で省略），tmux でジョブを起動する |
 | `status` | 全サーバの実行中ジョブと GPU の状況 |
 | `logs NAME [-n N] [-f]` | ジョブのログを表示する．ジョブのあるサーバを自動で探す |
 | `kill NAME` | ジョブを止める．ジョブのあるサーバを自動で探す |
@@ -170,9 +170,10 @@
 - ジョブ名: 英数字で始まり，英数字・`_`・`-` のみ，1〜64 文字
 - **いずれかのサーバで同名のジョブが実行中ならエラー**
 - tmux セッション名をジョブ名とし，サーバの `remote_dir` で `<uv> run <CMD>` を実行する．接続が切れても継続する
-- ジョブに渡す環境変数: `CUDA_VISIBLE_DEVICES=<選んだ GPU の index>`・`TIAS_DATA_ROOT=<そのサーバの data_dir>`・`CUDA_DEVICE_ORDER=PCI_BUS_ID`（CUDA の GPU 番号を nvidia-smi の index にそろえる．そろえないと空きと判定したのと別の GPU を使いうる）・`PYTHONUNBUFFERED=1`・`--env` で指定したもの．**前の 4 つは `--env` で上書きできない**（GPU の割り当てを迂回させないため）
+- ジョブに渡す環境変数: `CUDA_VISIBLE_DEVICES=<選んだ GPU の index>`・`TIAS_DATA_ROOT=<そのサーバの data_dir>`・`CUDA_DEVICE_ORDER=PCI_BUS_ID`（CUDA の GPU 番号を nvidia-smi の index にそろえる．そろえないと空きと判定したのと別の GPU を使いうる）・`PYTHONUNBUFFERED=1`・`TIAS_GIT_COMMIT`（手元の `git rev-parse --short HEAD`．未コミットの変更があれば末尾に `-dirty`．git が使えなければ設定しない．サーバには `.git` を送らないため，実験 ID の git ハッシュをここから得る．[SPEC_01](SPEC_01_アーキテクチャ設計.md)「実験の出力」）・`--env` で指定したもの．**`--env` 以外の 5 つは `--env` で上書きできない**（GPU の割り当てと実験の記録を迂回させないため）
 - ログ: `remote_dir/runs/_remote_logs/<ジョブ名>.log` に，開始行（サーバ名・GPU・日時）と終了コード行（`=== [日時] exit <終了コード>`）を付けて追記する
 - `--dry-run` を付けると GPU の選択までを行い，送信・起動はしない
+- **`--cpu`**: GPU を使わないジョブ（manifest の生成・データセットの集計等）用．GPU の観測・選択を行わず，`CUDA_VISIBLE_DEVICES` を空文字で渡す（GPU を誤って掴まないため）．サーバは `--server` で指定したもの，省略時は候補サーバ（`data_ready: true`．`--no-data` で全サーバ）を priority 順に見て最初に接続できたもの．`--gpu`・`--force`・`--observe` とは同時に指定できない．ログの開始行の GPU は「なし（CPU）」とする
 - 起動後，選んだサーバと GPU を表示する
 
 ### pull
diff --git "a/docs/06_TEST/TEST_02_\343\203\207\343\203\274\343\202\277\343\202\273\343\203\203\343\203\210\351\233\206\350\250\210\347\265\220\346\236\234.md" "b/docs/06_TEST/TEST_02_\343\203\207\343\203\274\343\202\277\343\202\273\343\203\203\343\203\210\351\233\206\350\250\210\347\265\220\346\236\234.md"
new file mode 100644
index 0000000..370ed71
--- /dev/null
+++ "b/docs/06_TEST/TEST_02_\343\203\207\343\203\274\343\202\277\343\202\273\343\203\203\343\203\210\351\233\206\350\250\210\347\265\220\346\236\234.md"
@@ -0,0 +1,83 @@
+# データセット集計結果 (Dataset Survey Results)
+
+`tias-dataset survey` で実データ（1085 枚）を集計した結果．集計は計算サーバ（Newton）上で行い，手元には集計値と図だけを回収した（[SPEC_01「データセット集計の出力」](../04_SPEC/SPEC_01_アーキテクチャ設計.md)）．
+
+| 項目 | 値 |
+| --- | --- |
+| 実行日 | 2026-09-27 |
+| 実験 ID | `20260927-235115_survey_36b6e40-dirty` |
+| 実行場所 | Newton（`tias-remote run --cpu`．所要 106.5 秒） |
+| 回収したもの | `dataset_summary.json`・`config.yaml`・`log.txt`・`figures/lab_by_group.png`・`figures/lab_group_means_ab.png`（回収しなかったファイル 0 件） |
+
+## データの健全性 (Integrity)
+
+| 項目 | 結果 |
+| --- | --- |
+| 読めた画像 | 1085 / 1085（読めない 0・欠落 0） |
+| RGB 以外のモード・アルファ付き | 0・0 |
+| 舌領域の無い画像 | 0 |
+| 画像サイズ | 幅 449〜900（中央値 675）・高さ 279〜1025（中央値 611） |
+| 舌領域の割合（背景でない画素） | 0.50〜0.80（平均 0.64）．グループ間の差は小さい（平均 0.62〜0.66） |
+
+## 条件別の件数 (Counts by Condition)
+
+| クラス | ややあり込み | ややあり除外 |
+| --- | --- | --- |
+| 淡白 (`pale`) | 104 | 53 |
+| 淡紅 (`light_red`) | 337 | 337 |
+| 紅 (`red`) | 119 | 61 |
+| 暗赤紅 (`dark_red`) | 380 | 247 |
+| 紫 (`purple`) | 145 | 56 |
+| **合計** | **1085** | **754** |
+
+既定の分割（seed 42・val 0.15・test 0.15・9 グループで層化）: 患者数 train 759・val 163・test 163．5-fold の held_out は各 217．
+
+## 舌領域の色 (Lab of Tongue Region)
+
+画像ごとに舌領域の平均 Lab を求め，グループごとにその平均 ± 標準偏差を取ったもの．
+
+| グループ | n | L\* | a\* | b\* |
+| --- | --- | --- | --- | --- |
+| `light_red_normal` | 337 | 55.3 ± 4.2 | 27.4 ± 2.7 | 8.0 ± 1.8 |
+| `pale_strong` | 53 | 57.1 ± 5.9 | 24.2 ± 2.8 | 9.9 ± 2.0 |
+| `pale_mild` | 51 | 53.3 ± 5.8 | 25.4 ± 2.5 | 9.3 ± 1.9 |
+| `red_strong` | 61 | 46.8 ± 4.9 | 32.1 ± 3.0 | 8.1 ± 2.2 |
+| `red_mild` | 58 | 51.2 ± 4.6 | 29.9 ± 2.7 | 7.4 ± 2.1 |
+| `dark_red_strong` | 247 | 46.7 ± 5.0 | 26.4 ± 3.0 | 7.1 ± 2.2 |
+| `dark_red_mild` | 133 | 52.3 ± 4.7 | 25.8 ± 2.6 | 7.6 ± 2.1 |
+| `purple_strong` | 56 | 50.1 ± 5.1 | 23.8 ± 2.5 | 5.3 ± 2.3 |
+| `purple_mild` | 89 | 56.5 ± 4.2 | 24.9 ± 3.3 | 6.3 ± 1.8 |
+
+読み取れる傾向（「あり」の群）:
+
+- **紅**は a\*（赤み）が最も高い（32）
+- **暗赤紅**は赤み（a\* 26）は淡紅と同程度のまま，L\* が低い（暗い）
+- **紫**は b\* が最も低い（青寄り）
+- **淡白**は a\* が低く，L\* と b\* が高い
+
+## 「ややあり」はどちらに近いか (Where Mild Sits)
+
+グループ平均どうしの色差 ΔE（CIE76）．
+
+| グループ | 淡紅との ΔE | 同じクラスの「あり」との ΔE | 近いほう |
+| --- | --- | --- | --- |
+| `pale_mild` | **3.12** | 4.02 | 淡紅 |
+| `dark_red_mild` | **3.47** | 5.68 | 淡紅 |
+| `purple_mild` | **3.26** | 6.56 | 淡紅 |
+| `red_mild` | 4.88 | 4.88 | ほぼ等距離 |
+
+- 4 グループ中 3 つは色の上でも淡紅に近い．「ややあり」は臨床上は淡紅と判断されることが多いという知見（[SPEC_02「程度（ややあり）の扱い」](../04_SPEC/SPEC_02_学習・評価仕様.md)）と整合する
+- 紅だけは「あり」と淡紅のちょうど中間にある
+- 暗赤紅・紫の「ややあり」は，主に L\*（明るさ）が淡紅に近づいている（暗赤紅: あり 46.7 → ややあり 52.3 → 淡紅 55.3）
+
+## 分類の難しさについて (Separability)
+
+- 「あり」どうし・「あり」と淡紅のグループ平均の差は ΔE 4〜13 程度（例: 淡紅と淡白＿あり 4.1，暗赤紅＿ありと紫＿あり 4.6，淡白＿ありと紅＿あり 13.1）
+- 一方，グループ内の画像ごとのばらつき（標準偏差）は L\* で 4〜6，a\* で 2.5〜3，b\* で 2 程度あり，**平均色だけでは各グループの分布が大きく重なる**（`figures/lab_by_group.png` の箱ひげ図）
+- したがって，舌全体の平均色だけで分類するのは難しく，モデルには色の空間的な分布（部位ごとの違い等）を使うことが期待される．精度の見込みは控えめに置く
+- L\*（明るさ）の差がクラスを分ける主要な手がかりの 1 つになっているため，撮影条件（露出）のばらつきが性能に効きうる．色を変えるデータ拡張を禁止している方針（SPEC_02）は維持する
+
+## 残る問い (Open Questions)
+
+- 「ややあり」を含めるか否かの結論は，両条件の実験結果（Step 5 以降）で判断する
+- 紅＿ややあり が中間に位置することの臨床的な解釈
diff --git a/docs/PROGRESS.md b/docs/PROGRESS.md
index 4b62166..03dff75 100644
--- a/docs/PROGRESS.md
+++ b/docs/PROGRESS.md
@@ -78,3 +78,13 @@
   - 発見: Archimedes の GPU 0 に，42 日間起動したまま観測中ずっと 0% のプロセス（メモリ確保のみ）がある．今回の表示で消し忘れのようなプロセスが一目で分かるようになった
   - 未決・既知の制約: 「最後に使った時刻」は nvidia-smi に履歴が無いため取れない（サーバに常駐の記録処理を置く必要があり別作業とした）．計算プロセスの一覧が空で返った場合，本当に 0 件か権限で見えないだけかは区別できない（現状の両サーバでは他人のプロセスが見えている）
 
+## Step 3: データセット集計
+
+- [x] **`tias-dataset`（manifest 生成・集計）と「ややあり」の実験切り替えを実装し，実データを集計**: 両サーバで manifest を生成し，Newton で 1085 枚を集計して集計値と図だけを回収した（結果は [TEST_02](06_TEST/TEST_02_データセット集計結果.md)）．
+  - 背景: 「ややあり」は臨床上は淡紅（正常）と判断されることが多い境界例である（ユーザー）．**入れる場合と入れない場合の両方で実験する**ことにした（設定 `data.severities`）
+  - 設計判断 ①: **分割は全データで 1 回だけ行い，除外は分割の後に適用する**．条件ごとに分割し直すと test の患者が入れ替わり，差が条件によるものか分割によるものか切り分けられない．「ややあり除外」の各分割は「込み」の部分集合になる
+  - 設計判断 ②: 層化をクラス単位から**クラス × 程度の 9 グループ**に変えた（mild を抜いた後もクラス比を保つため）
+  - 設計判断 ③: `tias-remote run --cpu` を追加した．manifest 生成・集計は CPU だけで動くのに，`run` が必ず空き GPU を要求していた（Newton の GPU が全て使用中で起動できない状況があった）
+  - 結果: 読めない画像 0．**ややありの 4 グループ中 3 つは色（ΔE）の上でも淡紅に近く**，臨床の知見と整合した（紅だけは等距離）．一方でグループ間の平均色の差（ΔE 4〜13）に比べてグループ内のばらつきが大きく，平均色だけでは分布が大きく重なる → 精度の見込みは控えめに置く
+  - 仕組み: 実験 ID の git ハッシュは，サーバに `.git` を送らないため `tias-remote run` が手元で求めて `TIAS_GIT_COMMIT` で渡す
+
diff --git a/pyproject.toml b/pyproject.toml
index 68e062c..7d7d308 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -17,6 +17,7 @@
 ]
 
 [project.scripts]
+tias-dataset = "tias_judge_model.cli.dataset:main"
 tias-remote = "tias_judge_model.cli.remote:main"
 
 [dependency-groups]
diff --git a/src/tias_judge_model/cli/dataset.py b/src/tias_judge_model/cli/dataset.py
new file mode 100644
index 0000000..0401091
--- /dev/null
+++ b/src/tias_judge_model/cli/dataset.py
@@ -0,0 +1,327 @@
+"""`tias-dataset` コマンド: manifest の生成とデータセットの集計（SPEC_01「CLI」）.
+
+サブコマンド:
+
+- `build-manifest --config PATH [--overwrite]`: `images/` を走査して manifest を書き出す
+- `survey --config PATH [--out-root runs]`: データセットを集計し，`runs/<実験ID>/` に集計値だけを
+  書き出す（`dataset_summary.json`・`config.yaml`・`log.txt`・`figures/*.png`）．最後に実験 ID を
+  標準出力へ出す（`tias-remote pull <実験ID>` に使うため）
+
+実データを読むためサーバで実行する．ログ・出力に患者 ID・ファイル名・画像単位の値を出さない．
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import os
+import re
+import sys
+import time
+from collections.abc import Callable, Mapping, Sequence
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+import yaml
+from pydantic import ValidationError
+
+from tias_judge_model.data.manifest import build_manifest_records, read_manifest, write_manifest
+from tias_judge_model.data.survey import (
+    LAB_CHANNELS,
+    collect_image_stats,
+    lab_values_by_group,
+    summarize_dataset,
+)
+from tias_judge_model.data.survey_figures import (
+    LAB_BOXPLOT_FILENAME,
+    LAB_MEANS_AB_FILENAME,
+    plot_group_means_ab,
+    plot_lab_by_group,
+)
+from tias_judge_model.schema import GIT_COMMIT_ENV_VAR, ExperimentConfig, load_config
+
+logger = logging.getLogger(__name__)
+
+SURVEY_RUN_NAME = "survey"
+NO_GIT = "nogit"
+SUMMARY_FILENAME = "dataset_summary.json"
+CONFIG_FILENAME = "config.yaml"
+LOG_FILENAME = "log.txt"
+FIGURES_DIRNAME = "figures"
+
+# 実験 ID に埋め込むため，ファイル名・RUN_ID として安全な文字だけを許す（git の短縮ハッシュと
+# `-dirty` を想定）．
+_GIT_COMMIT_RE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$")
+_LOG_FORMAT = "%(asctime)s %(levelname)s %(name)s: %(message)s"
+
+_EPILOG = """\
+使用例（サーバ上で実行する．手元では configs/synthetic.yaml で合成データを使う）:
+  uv run tias-dataset build-manifest --config configs/newton.yaml
+  uv run tias-dataset build-manifest --config configs/newton.yaml --overwrite
+  uv run tias-dataset survey --config configs/newton.yaml
+  uv run tias-remote run --name survey -- tias-dataset survey --config configs/newton.yaml
+
+環境変数:
+  TIAS_DATA_ROOT   data.root を上書き（tias-remote run が各サーバの data_dir を渡す）
+  TIAS_GIT_COMMIT  実験 ID に入れる git の短縮ハッシュ（tias-remote run が渡す．無ければ nogit）
+"""
+
+
+def resolve_git_commit(environ: Mapping[str, str]) -> str:
+    """実験 ID に入れる git の短縮ハッシュを環境変数から決める.
+
+    Args:
+        environ: 参照する環境変数．
+
+    Returns:
+        `TIAS_GIT_COMMIT` の値．未設定・空なら `nogit`．
+
+    Raises:
+        ValueError: 値が実験 ID に使えない文字を含む場合．
+    """
+    value = environ.get(GIT_COMMIT_ENV_VAR, "").strip()
+    if not value:
+        return NO_GIT
+    if not _GIT_COMMIT_RE.match(value):
+        raise ValueError(
+            f"環境変数 {GIT_COMMIT_ENV_VAR} の値が不正である: {value!r}"
+            "（英数字で始まり，英数字・_・- のみ，64 文字以内）"
+        )
+    return value
+
+
+def make_run_id(now: datetime, name: str, git_commit: str) -> str:
+    """実験 ID `YYYYmmdd-HHMMSS_<名前>_<git短縮ハッシュ>` を作る（SPEC_01「実験の出力」）.
+
+    Args:
+        now: 実行日時．
+        name: 名前（データセット集計なら `survey`）．
+        git_commit: git の短縮ハッシュ（または `nogit`）．
+
+    Returns:
+        実験 ID．
+    """
+    return f"{now:%Y%m%d-%H%M%S}_{name}_{git_commit}"
+
+
+def resolved_config_document(
+    config: ExperimentConfig, *, run_id: str, git_commit: str, command: str
+) -> dict[str, Any]:
+    """`config.yaml` に書く内容（解決済み設定 ＋ 実験 ID ＋ git ハッシュ）を作る.
+
+    Args:
+        config: 解決済みの設定（環境変数の上書き適用後）．
+        run_id: 実験 ID．
+        git_commit: git の短縮ハッシュ（または `nogit`）．
+        command: 実行したサブコマンド名．
+
+    Returns:
+        YAML に書き出せる dict．
+    """
+    return {
+        "run": {"id": run_id, "command": command, "git_commit": git_commit},
+        "config": config.model_dump(mode="json"),
+    }
+
+
+# ---------------------------------------------------------------------------
+# build-manifest
+# ---------------------------------------------------------------------------
+
+
+def _cmd_build_manifest(args: argparse.Namespace) -> int:
+    config = load_config(args.config)
+    manifest_path = config.data.manifest_path
+    if manifest_path.exists() and not args.overwrite:
+        logger.error("manifest が既にある: %s（作り直すには --overwrite を付ける）", manifest_path)
+        return 1
+    records = build_manifest_records(config.data.images_dir)
+    write_manifest(records, manifest_path)
+    logger.info("manifest を書き出した: %s（%d 件）", manifest_path, len(records))
+    return 0
+
+
+# ---------------------------------------------------------------------------
+# survey
+# ---------------------------------------------------------------------------
+
+
+def _cmd_survey(args: argparse.Namespace) -> int:
+    config = load_config(args.config)
+    git_commit = resolve_git_commit(os.environ)
+    run_id = make_run_id(datetime.now(), SURVEY_RUN_NAME, git_commit)
+    run_dir = args.out_root / run_id
+    if run_dir.exists():
+        logger.error("実験ディレクトリが既にある: %s（時間をおいて再実行する）", run_dir)
+        return 1
+    run_dir.mkdir(parents=True)
+
+    file_handler = logging.FileHandler(run_dir / LOG_FILENAME, encoding="utf-8")
+    file_handler.setFormatter(logging.Formatter(_LOG_FORMAT))
+    root = logging.getLogger()
+    root.addHandler(file_handler)
+    try:
+        _run_survey(config, run_dir, run_id=run_id, git_commit=git_commit)
+    except (ValueError, OSError) as exc:
+        # log.txt にも失敗の理由を残すため，ハンドラを外す前にここで記録する．
+        logger.error("%s", exc)
+        return 1
+    finally:
+        root.removeHandler(file_handler)
+        file_handler.close()
+    sys.stdout.write(f"{run_id}\n")
+    sys.stdout.flush()
+    return 0
+
+
+def _run_survey(config: ExperimentConfig, run_dir: Path, *, run_id: str, git_commit: str) -> None:
+    started = time.monotonic()
+    logger.info("データセット集計を開始する（実験 ID %s）", run_id)
+    _write_yaml(
+        run_dir / CONFIG_FILENAME,
+        resolved_config_document(config, run_id=run_id, git_commit=git_commit, command="survey"),
+    )
+
+    records = read_manifest(config.data.manifest_path)
+    stats = collect_image_stats(records, config.data.images_dir)
+    summary = summarize_dataset(
+        records,
+        stats,
+        seed=config.split.seed,
+        val_ratio=config.split.val_ratio,
+        test_ratio=config.split.test_ratio,
+        n_folds=config.split.n_folds,
+        configured_severities=config.data.severities,
+    )
+    summary = {"run_id": run_id, "git_commit": git_commit, **summary}
+    _write_json(run_dir / SUMMARY_FILENAME, summary)
+
+    figures_dir = run_dir / FIGURES_DIRNAME
+    plot_lab_by_group(lab_values_by_group(records, stats), figures_dir / LAB_BOXPLOT_FILENAME)
+    groups = summary["lab"]["groups"]
+    plot_group_means_ab(
+        {g: _channel_values(s, "mean") for g, s in groups.items()},
+        {g: _channel_values(s, "std") for g, s in groups.items()},
+        figures_dir / LAB_MEANS_AB_FILENAME,
+    )
+
+    loading = summary["loading"]
+    counts = summary["counts"]["total"]
+    logger.info(
+        "集計した: 画像 %d 件・患者 %d 人（読めない %d 件・RGB 以外 %d 件・アルファ付き %d 件）",
+        counts["images"],
+        counts["patients"],
+        loading["unreadable"],
+        loading["non_rgb_mode"],
+        loading["with_alpha"],
+    )
+    for item in summary["delta_e"]["mild_comparison"]:
+        logger.info(
+            "%s: ΔE（対 %s）= %s・ΔE（対 %s）= %s → %s に近い",
+            item["group"],
+            item["normal_group"],
+            item["delta_e_to_normal"],
+            item["strong_group"],
+            item["delta_e_to_strong"],
+            item["closer_to"],
+        )
+    logger.info("出力先: %s（所要 %.1f 秒）", run_dir, time.monotonic() - started)
+
+
+def _channel_values(stats: Mapping[str, Any], key: str) -> tuple[float, ...] | None:
+    values = [stats[c][key] for c in LAB_CHANNELS]
+    if key == "mean" and any(v is None for v in values):
+        return None
+    return tuple(values)
+
+
+def _write_json(path: Path, data: Mapping[str, Any]) -> None:
+    with path.open("w", encoding="utf-8", newline="\n") as f:
+        json.dump(data, f, ensure_ascii=False, indent=2)
+        f.write("\n")
+
+
+def _write_yaml(path: Path, data: Mapping[str, Any]) -> None:
+    with path.open("w", encoding="utf-8", newline="\n") as f:
+        yaml.safe_dump(dict(data), f, allow_unicode=True, sort_keys=False)
+
+
+# ---------------------------------------------------------------------------
+# エントリポイント
+# ---------------------------------------------------------------------------
+
+
+def _parse_args(argv: Sequence[str] | None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        prog="tias-dataset",
+        description="manifest の生成とデータセットの集計（集計値だけを書き出す）",
+        epilog=_EPILOG,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    sub = parser.add_subparsers(dest="subcommand", required=True)
+
+    p_build = sub.add_parser(
+        "build-manifest",
+        help="images/ を走査して manifest を書き出す",
+        description=(
+            "<data.root>/images/<label>_<severity>/*.png を走査して manifest を書き出す．"
+            "既存の manifest があれば --overwrite が無い限り止まる．"
+        ),
+    )
+    p_build.add_argument("--config", type=Path, required=True, help="実験設定 YAML．")
+    p_build.add_argument("--overwrite", action="store_true", help="既存の manifest を上書きする．")
+
+    p_survey = sub.add_parser(
+        "survey",
+        help="データセットを集計して runs/<実験ID>/ に集計値だけを書き出す",
+        description=(
+            "manifest と画像を読み，件数・読み込み・サイズ・舌領域の割合・Lab 色・グループ間の"
+            "色差・分割の件数を集計する．画像単位の値・患者 ID・ファイル名は出力しない．"
+            "最後に実験 ID を標準出力へ出す．"
+        ),
+    )
+    p_survey.add_argument("--config", type=Path, required=True, help="実験設定 YAML．")
+    p_survey.add_argument(
+        "--out-root", type=Path, default=Path("runs"), help="実験ディレクトリの親（既定: runs）．"
+    )
+    return parser.parse_args(argv)
+
+
+_HANDLERS: dict[str, Callable[[argparse.Namespace], int]] = {
+    "build-manifest": _cmd_build_manifest,
+    "survey": _cmd_survey,
+}
+
+
+def _configure_logging() -> None:
+    # ログは標準エラーへ（標準出力は実験 ID の受け渡しに使うため汚さない）．
+    handler = logging.StreamHandler(sys.stderr)
+    handler.setFormatter(logging.Formatter(_LOG_FORMAT))
+    logging.basicConfig(level=logging.INFO, handlers=[handler])
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    """tias-dataset コマンドのメインエントリポイント.
+
+    Args:
+        argv: 引数リスト．None のとき sys.argv[1:] を使用．
+
+    Returns:
+        終了コード（成功 0・入力の問題 1）．
+    """
+    args = _parse_args(argv)
+    _configure_logging()
+    try:
+        return _HANDLERS[args.subcommand](args)
+    except ValidationError as exc:
+        logger.error("設定が不正である:\n%s", exc)
+        return 1
+    except (ValueError, OSError) as exc:
+        logger.error("%s", exc)
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/src/tias_judge_model/cli/remote.py b/src/tias_judge_model/cli/remote.py
index 4bb4ad7..0d8febc 100644
--- a/src/tias_judge_model/cli/remote.py
+++ b/src/tias_judge_model/cli/remote.py
@@ -56,6 +56,7 @@
     build_push_command,
     build_run_command,
     build_ssh_argv,
+    format_git_commit,
     job_log_path,
     validate_job_name,
 )
@@ -76,8 +77,10 @@
 from tias_judge_model.remote.files import PushEntry, collect_push_entries, find_project_root
 from tias_judge_model.remote.gpu import (
     ServerProbe,
+    check_cpu_options,
     check_selection_options,
     parse_probe_output,
+    select_cpu_server,
     select_gpu,
     servers_with_session,
 )
@@ -103,6 +106,8 @@
 _QUERY_TIMEOUT_MARGIN_SEC = 30
 _MAX_STDERR_CHARS = 160
 _HOST_KEY_FAILURE = b"Host key verification failed"
+# 手元の git（rev-parse・status）の応答待ちの上限
+_GIT_TIMEOUT_SEC = 30
 
 _EPILOG = """\
 使用例:
@@ -111,6 +116,7 @@
   uv run tias-remote push                                   # 接続できる全サーバへコードを送る
   uv run tias-remote run --name exp1 -- pytest              # 空き GPU を自動で選んで起動
   uv run tias-remote run --name exp2 --server Newton --gpu 1 -- python -m ...   # GPU を指定
+  uv run tias-remote run --name survey --cpu -- tias-dataset survey --config ...   # GPU なし
   uv run tias-remote logs exp1 -f                           # ログを追従
   uv run tias-remote kill exp1                              # ジョブを止める
   uv run tias-remote pull 20260927-120000_newton_abc1234    # 回収ホワイトリストのみ持ち帰る
@@ -292,6 +298,43 @@
     )
 
 
+def _run_git(project_root: Path, *git_args: str) -> str | None:
+    """手元で git を実行して標準出力を返す（git が無い・失敗したら None）."""
+    try:
+        completed = subprocess.run(  # noqa: S603
+            ["git", *git_args],
+            cwd=project_root,
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            timeout=_GIT_TIMEOUT_SEC,
+            check=False,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+    if completed.returncode != 0:
+        return None
+    return completed.stdout
+
+
+def _local_git_commit(project_root: Path) -> str | None:
+    """ジョブに `TIAS_GIT_COMMIT` として渡す手元の git の短縮ハッシュを求める.
+
+    未コミットの変更（未追跡のファイルを含む）があれば末尾に `-dirty` を付ける．git が
+    使えない・リポジトリでない場合は None（渡さない．ジョブ側は `nogit` とする）．
+    """
+    head = _run_git(project_root, "rev-parse", "--short", "HEAD")
+    if head is None:
+        logger.warning("git のコミットハッシュを取得できなかった（実験 ID は nogit になる）")
+        return None
+    status = _run_git(project_root, "status", "--porcelain")
+    if status is None:
+        logger.warning("git の変更状況を取得できなかった（実験 ID は nogit になる）")
+        return None
+    return format_git_commit(head, dirty=bool(status.strip()))
+
+
 def _as_exit_code(rc: int) -> int:
     """ssh の結果の終了コードを CLI の終了コードにする（応答待ちの打ち切り等の負値は 1）."""
     return rc if rc >= 0 else 1
@@ -532,33 +575,13 @@
 # ---------------------------------------------------------------------------
 
 
-def _cmd_run(args: argparse.Namespace, ctx: _Context) -> int:
-    """run サブコマンド: 空き GPU を選び，コードを送って tmux でジョブを起動する."""
-    command = list(args.command)
-    if command and command[0] == "--":
-        command = command[1:]
-    if not command:
-        raise ValueError(
-            "実行するコマンドを -- の後に指定する（例: tias-remote run --name x -- python ...）"
-        )
-    name = validate_job_name(args.name)
-    check_selection_options(server_name=args.server, gpu_index=args.gpu, force=args.force)
-    if args.server is not None:
-        ctx.config.find_server(args.server)
-    threshold = _threshold_for(ctx, args.observe)
+def _select_gpu_target(
+    args: argparse.Namespace, probes: Sequence[ServerProbe]
+) -> tuple[ServerConfig, int, str] | None:
+    """GPU ジョブの実行先（サーバ・GPU・GPU の状態）を選び，警告を出す.
 
-    probes = _probe_servers(ctx, ctx.config.ordered_servers(), threshold)
-    _warn_unreachable(probes)
-    running = servers_with_session(probes, name, jobs_only=False)
-    if running:
-        names = ", ".join(probe.server.name for probe in running)
-        raise ValueError(
-            f"ジョブ名 {name!r} の tmux セッションが {names} で実行中である"
-            "（--name で別名を付けるか，終了を待つ）"
-        )
-    if any(not probe.reachable for probe in probes):
-        logger.warning("接続できないサーバでは同名ジョブの有無を確認していない")
-
+    選べなければ状況を表示して None を返す．
+    """
     selection = select_gpu(
         probes,
         server_name=args.server,
@@ -574,7 +597,7 @@
             args.server or scope,
             "--no-data 指定" if args.no_data else "data_ready: true",
         )
-        return 1
+        return None
     if selection.forced:
         logger.warning(
             "%s の GPU %d は%sだが，--force により使う（他のユーザーの計算と競合しうる）",
@@ -585,23 +608,82 @@
     shared_warning = format_shared_warning(selection)
     if shared_warning is not None:
         logger.warning("%s", shared_warning)
+    return selection.server, selection.gpu_index, selection.state.value
 
-    server = selection.server
-    env = build_job_env(selection.gpu_index, args.env)
+
+def _select_cpu_target(
+    args: argparse.Namespace, probes: Sequence[ServerProbe]
+) -> tuple[ServerConfig, None, str] | None:
+    """CPU ジョブ（--cpu）の実行先サーバを選ぶ（選べなければエラーを出して None）."""
+    server = select_cpu_server(probes, server_name=args.server, include_not_ready=args.no_data)
+    if server is None:
+        logger.error(
+            "接続できる%sが無いため，ジョブを起動しなかった",
+            "サーバ" if args.no_data else "データ配置済み（data_ready: true）のサーバ",
+        )
+        return None
+    return server, None, ""
+
+
+def _describe_target(server: ServerConfig, gpu_index: int | None, state: str = "") -> str:
+    """実行先の表示（例: `Newton の GPU 1（未使用）`・`Newton（GPU なし・CPU のみ）`）."""
+    if gpu_index is None:
+        return f"{server.name}（GPU なし・CPU のみ）"
+    return f"{server.name} の GPU {gpu_index}" + (f"（{state}）" if state else "")
+
+
+def _cmd_run(args: argparse.Namespace, ctx: _Context) -> int:
+    """run サブコマンド: 空き GPU（--cpu なら GPU なし）を選び，コードを送って tmux で起動する."""
+    command = list(args.command)
+    if command and command[0] == "--":
+        command = command[1:]
+    if not command:
+        raise ValueError(
+            "実行するコマンドを -- の後に指定する（例: tias-remote run --name x -- python ...）"
+        )
+    name = validate_job_name(args.name)
+    if args.cpu:
+        check_cpu_options(gpu_index=args.gpu, force=args.force, observe_sec=args.observe)
+        # GPU を選ばないため観測しない（同名ジョブの確認と接続可否だけを見る）
+        threshold = None
+    else:
+        check_selection_options(server_name=args.server, gpu_index=args.gpu, force=args.force)
+        threshold = _threshold_for(ctx, args.observe)
+    if args.server is not None:
+        ctx.config.find_server(args.server)
+
+    probes = _probe_servers(ctx, ctx.config.ordered_servers(), threshold)
+    _warn_unreachable(probes)
+    running = servers_with_session(probes, name, jobs_only=False)
+    if running:
+        names = ", ".join(probe.server.name for probe in running)
+        raise ValueError(
+            f"ジョブ名 {name!r} の tmux セッションが {names} で実行中である"
+            "（--name で別名を付けるか，終了を待つ）"
+        )
+    if any(not probe.reachable for probe in probes):
+        logger.warning("接続できないサーバでは同名ジョブの有無を確認していない")
+
+    target = _select_cpu_target(args, probes) if args.cpu else _select_gpu_target(args, probes)
+    if target is None:
+        return 1
+    server, gpu_index, state = target
+
+    env = build_job_env(gpu_index, args.env, git_commit=_local_git_commit(ctx.project_root))
     script = build_job_script(
         server.remote_dir,
         name,
         command,
         uv_path=server.uv,
         server_name=server.name,
-        gpu_index=selection.gpu_index,
+        gpu_index=gpu_index,
         env=env,
         path_env={DATA_ROOT_ENV_VAR: server.data_dir},
     )
     remote_command = build_run_command(server.remote_dir, name, script)
     if args.dry_run:
         _write_stdout(
-            f"選んだ GPU: {server.name} の GPU {selection.gpu_index}（{selection.state.value}）\n"
+            f"選んだ実行先: {_describe_target(server, gpu_index, state)}\n"
             f"実行するリモートコマンド:\n{remote_command}\n"
             "（--dry-run のため送信・起動していない）\n"
         )
@@ -627,7 +709,7 @@
 
     log_path = f"{server.remote_dir}/{job_log_path(name)}"
     _write_stdout(
-        f"ジョブを起動した: {name}（{server.name} の GPU {selection.gpu_index}）\n"
+        f"ジョブを起動した: {name}（{_describe_target(server, gpu_index)}）\n"
         f"  環境変数: {' '.join(f'{k}={v}' for k, v in env.items())} "
         f"{DATA_ROOT_ENV_VAR}={server.data_dir}\n"
         f"  ログ    : {server.name}:{log_path}\n"
@@ -943,6 +1025,16 @@
         help="--gpu で指定した GPU が使用中・状態不明でも使う．",
     )
     p_run.add_argument(
+        "--cpu",
+        action="store_true",
+        help=(
+            "GPU を使わないジョブ（manifest の生成・データセットの集計等）として起動する．"
+            "GPU を観測・選択せず，CUDA_VISIBLE_DEVICES を空にする．サーバは --server，"
+            "省略時は候補サーバを priority 順に見て最初に接続できたもの．"
+            "--gpu・--force・--observe とは同時に指定できない．"
+        ),
+    )
+    p_run.add_argument(
         "--no-data",
         action="store_true",
         help="データ未配置（data_ready: false）のサーバも候補にする．",
@@ -960,7 +1052,10 @@
         action="append",
         default=[],
         metavar="KEY=VALUE",
-        help="ジョブに追加で渡す環境変数．複数指定可．",
+        help=(
+            "ジョブに追加で渡す環境変数．複数指定可（tias-remote が設定する CUDA_VISIBLE_DEVICES・"
+            "TIAS_DATA_ROOT・TIAS_GIT_COMMIT 等は指定できない）．"
+        ),
     )
     p_run.add_argument(
         "--dry-run",
diff --git a/src/tias_judge_model/data/color.py b/src/tias_judge_model/data/color.py
new file mode 100644
index 0000000..2bb3221
--- /dev/null
+++ b/src/tias_judge_model/data/color.py
@@ -0,0 +1,123 @@
+"""舌領域の色の計算（sRGB → CIE L*a*b*）と色差 ΔE.
+
+変換は sRGB（ガンマ補正を外して線形化）→ XYZ（D65）→ CIE L*a*b*（D65 白色点）の順で，
+新しい依存を増やさないため NumPy だけで行う（SPEC_01「データセット集計の出力」）．
+背景（マスク外）は RGB がすべて 0 の画素と定義する（TEST_01．マスク外は黒 (0,0,0)）．
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+# IEC 61966-2-1（sRGB）の線形 RGB → XYZ（D65）の行列．
+_SRGB_TO_XYZ = np.array(
+    [
+        [0.4124564, 0.3575761, 0.1804375],
+        [0.2126729, 0.7151522, 0.0721750],
+        [0.0193339, 0.1191920, 0.9503041],
+    ],
+    dtype=np.float64,
+)
+# D65 の白色点（Y = 1 に正規化）．上の行列の行和と一致させ，sRGB 白が a* = b* = 0 になるようにする．
+D65_WHITE = _SRGB_TO_XYZ.sum(axis=1)
+
+# CIE L*a*b* の区分関数の定数（δ = 6/29）．
+_DELTA = 6.0 / 29.0
+
+
+def srgb_to_linear(rgb: np.ndarray) -> np.ndarray:
+    """sRGB の値（0〜1）のガンマ補正を外して線形 RGB にする.
+
+    Args:
+        rgb: sRGB の値（任意の形状, float, 値域 0.0〜1.0）．
+
+    Returns:
+        線形 RGB（入力と同じ形状, float64, 値域 0.0〜1.0）．
+    """
+    c = np.asarray(rgb, dtype=np.float64)
+    return np.where(c <= 0.04045, c / 12.92, ((c + 0.055) / 1.055) ** 2.4)
+
+
+# uint8 の 256 階調ぶんを先に線形化しておき，画素ごとのべき乗計算を避ける（大きな画像が多いため）．
+_LINEAR_LUT = srgb_to_linear(np.arange(256, dtype=np.float64) / 255.0)
+
+
+def linear_rgb_to_lab(linear: np.ndarray) -> np.ndarray:
+    """線形 RGB を CIE L*a*b*（D65）に変換する.
+
+    Args:
+        linear: 線形 RGB（`(..., 3)`, float, 値域 0.0〜1.0）．
+
+    Returns:
+        L*a*b*（`(..., 3)`, float64．L* は 0〜100）．
+    """
+    xyz = np.asarray(linear, dtype=np.float64) @ _SRGB_TO_XYZ.T  # (..., 3)
+    t = xyz / D65_WHITE
+    f = np.where(t > _DELTA**3, np.cbrt(t), t / (3.0 * _DELTA**2) + 4.0 / 29.0)
+    lightness = 116.0 * f[..., 1] - 16.0
+    a = 500.0 * (f[..., 0] - f[..., 1])
+    b = 200.0 * (f[..., 1] - f[..., 2])
+    return np.stack([lightness, a, b], axis=-1)
+
+
+def rgb8_to_lab(rgb: np.ndarray) -> np.ndarray:
+    """8 bit の sRGB 値を CIE L*a*b*（D65）に変換する.
+
+    Args:
+        rgb: sRGB 値（`(..., 3)`, uint8, 値域 0〜255）．
+
+    Returns:
+        L*a*b*（`(..., 3)`, float64）．
+
+    Raises:
+        ValueError: 最後の次元が 3 でない，または dtype が uint8 でない場合．
+    """
+    arr = np.asarray(rgb)
+    if arr.shape[-1:] != (3,):
+        raise ValueError(f"RGB の最後の次元は 3 でなければならない（形状 {arr.shape}）")
+    if arr.dtype != np.uint8:
+        raise ValueError(f"RGB の dtype は uint8 でなければならない（{arr.dtype}）")
+    return linear_rgb_to_lab(_LINEAR_LUT[arr])
+
+
+def tongue_mask(pixels: np.ndarray) -> np.ndarray:
+    """舌領域（背景でない画素）のマスクを返す.
+
+    背景は RGB がすべて 0 の画素とする（TEST_01．マスク外は黒 (0,0,0)）．
+
+    Args:
+        pixels: RGB 画像（`(H, W, 3)`, uint8）．
+
+    Returns:
+        舌領域なら True のマスク（`(H, W)`, bool）．
+    """
+    return np.any(np.asarray(pixels) != 0, axis=-1)
+
+
+def mean_tongue_lab(pixels: np.ndarray) -> np.ndarray | None:
+    """舌領域の画素の L*a*b* の平均を返す（画素ごとに Lab へ変換してから平均する）.
+
+    Args:
+        pixels: RGB 画像（`(H, W, 3)`, uint8）．
+
+    Returns:
+        舌領域の平均 L*a*b*（`(3,)`, float64）．舌領域の画素が無ければ None．
+    """
+    mask = tongue_mask(pixels)
+    if not mask.any():
+        return None
+    return rgb8_to_lab(np.asarray(pixels)[mask]).mean(axis=0)
+
+
+def delta_e_cie76(lab1: np.ndarray, lab2: np.ndarray) -> float:
+    """2 色の色差 ΔE（CIE76．L*a*b* のユークリッド距離）を返す.
+
+    Args:
+        lab1: 1 つめの L*a*b*（`(3,)`, float）．
+        lab2: 2 つめの L*a*b*（`(3,)`, float）．
+
+    Returns:
+        色差 ΔE*ab．
+    """
+    diff = np.asarray(lab1, dtype=np.float64) - np.asarray(lab2, dtype=np.float64)
+    return float(np.sqrt(np.sum(diff**2)))
diff --git a/src/tias_judge_model/data/split.py b/src/tias_judge_model/data/split.py
index d803891..48f656c 100644
--- a/src/tias_judge_model/data/split.py
+++ b/src/tias_judge_model/data/split.py
@@ -1,8 +1,13 @@
-"""患者単位の分割（単一分割・K-fold 交差検証）と分割後の集計.
+"""患者単位の分割（単一分割・K-fold 交差検証）・程度による絞り込み・分割後の集計.
 
 分割は常に `patient_id` 単位で行い，同一患者が複数の分割に跨らないようにする（SPEC_02）．
-1 患者は 1 つの label しか持たない（manifest の検証で保証）ため，患者の一覧を label で
-層化して分割すれば「患者単位」と「クラス層化」を同時に満たせる．
+層化は「クラス × 程度」（`<label>_<severity>` の 9 グループ）で行う．1 患者は 1 つの label
+しか持たない（manifest の検証で保証）ため，患者ごとに層化グループを 1 つ決めて患者の一覧を
+分ければ「患者単位」と「層化」を同時に満たせる．
+
+程度（`data.severities`）による除外は分割の**後**に適用する（`split_records`）．分割は常に
+manifest 全体で行うことで，「ややあり除外」の各分割が「ややあり込み」の各分割の部分集合になり，
+2 つの条件のモデルを同じ患者の test で比べられる（SPEC_02「程度（ややあり）の扱い」）．
 """
 
 from __future__ import annotations
@@ -16,7 +21,7 @@
 import numpy as np
 from sklearn.model_selection import StratifiedKFold
 
-from tias_judge_model.data.classes import CLASS_SLUGS
+from tias_judge_model.data.classes import ALL_DIR_NAMES, CLASS_SLUGS, SEVERITIES
 from tias_judge_model.data.manifest import ManifestRecord
 
 logger = logging.getLogger(__name__)
@@ -43,6 +48,10 @@
         """保存用に `{"train": [...], "val": [...], "test": [...]}` を返す."""
         return {"train": list(self.train), "val": list(self.val), "test": list(self.test)}
 
+    def parts(self) -> dict[str, tuple[str, ...]]:
+        """分割名 → 患者 ID（`train`・`val`・`test` の順）を返す."""
+        return {"train": self.train, "val": self.val, "test": self.test}
+
 
 @dataclass(frozen=True)
 class Fold:
@@ -62,6 +71,10 @@
         """保存用に `{"index": i, "train": [...], "held_out": [...]}` を返す."""
         return {"index": self.index, "train": list(self.train), "held_out": list(self.held_out)}
 
+    def parts(self) -> dict[str, tuple[str, ...]]:
+        """分割名 → 患者 ID（`train`・`held_out` の順）を返す."""
+        return {"train": self.train, "held_out": self.held_out}
+
 
 def patient_labels(records: Iterable[ManifestRecord]) -> dict[str, str]:
     """患者 ID → label の対応を作る.
@@ -83,17 +96,59 @@
     return mapping
 
 
+def record_group(record: ManifestRecord) -> str:
+    """レコードの層化グループ名（`<label>_<severity>`）を返す（組み合わせの検証はしない）.
+
+    Args:
+        record: manifest レコード．
+
+    Returns:
+        グループ名（例: `"red_mild"`）．
+    """
+    return f"{record.label}_{record.severity}"
+
+
+def patient_groups(records: Iterable[ManifestRecord]) -> dict[str, str]:
+    """患者 ID → 層化グループ（`<label>_<severity>`）の対応を作る.
+
+    同じ患者に複数の severity がある場合（1 患者複数枚）は，最も強いもの
+    （`strong` > `mild` > `normal`）をその患者のグループとする（SPEC_02「データ分割」）．
+
+    Args:
+        records: manifest レコード．
+
+    Returns:
+        患者 ID をキー，層化グループ名を値とする辞書．
+
+    Raises:
+        ValueError: 同一患者に異なる label が付いている，または未知の severity がある場合．
+    """
+    records = list(records)
+    labels_of = patient_labels(records)
+    # SEVERITIES は強い順（strong → mild → normal）に並んでいる．
+    rank = {severity: i for i, severity in enumerate(SEVERITIES)}
+    strongest: dict[str, str] = {}
+    for r in records:
+        if r.severity not in rank:
+            raise ValueError(f"未知の severity がある: {r.severity!r}（manifest の検証を通すこと）")
+        current = strongest.get(r.patient_id)
+        if current is None or rank[r.severity] < rank[current]:
+            strongest[r.patient_id] = r.severity
+    return {p: f"{label}_{strongest[p]}" for p, label in labels_of.items()}
+
+
 def split_train_val_test(
     records: Sequence[ManifestRecord], val_ratio: float, test_ratio: float, seed: int
 ) -> SplitResult:
-    """患者単位・クラス層化で train / val / test に分割する.
+    """患者単位・クラス × 程度の層化で train / val / test に分割する.
 
-    クラスごとに患者 ID を昇順に並べてから seed で並べ替え，先頭から test・val を
-    `round(患者数 × 比率)` 人ずつ取り，残りを train とする．同じ入力と seed なら
-    入力レコードの順序によらず同じ結果になる．
+    層化グループ（`<label>_<severity>`．`patient_groups`）ごとに患者 ID を昇順に並べてから
+    seed で並べ替え，先頭から test・val を `round(患者数 × 比率)` 人ずつ取り，残りを train
+    とする．同じ入力と seed なら入力レコードの順序によらず同じ結果になる．
+    `data.severities` による除外はここでは行わない（分割後に `split_records` で適用する）．
 
     Args:
-        records: manifest レコード（検証済み）．
+        records: manifest レコード（検証済み．除外前の全体）．
         val_ratio: val の比率（0 より大きく 1 未満）．
         test_ratio: test の比率（0 より大きく 1 未満）．
         seed: 乱数 seed．
@@ -103,21 +158,22 @@
 
     Raises:
         ValueError: 比率が不正，レコードが空，同一患者に異なる label がある，
-            またはあるクラスで train に患者が残らない場合．
+            またはある層化グループで train に患者が残らない場合．
     """
     if not (0.0 < val_ratio < 1.0 and 0.0 < test_ratio < 1.0 and val_ratio + test_ratio < 1.0):
         raise ValueError(
             f"分割比率が不正である（val_ratio={val_ratio}, test_ratio={test_ratio}）．"
             "それぞれ 0 より大きく，合計が 1 未満であること"
         )
-    by_class = _patients_by_class(records)
+    by_group = _patients_by_group(records)
     rng = np.random.default_rng(seed)
 
     train: list[str] = []
     val: list[str] = []
     test: list[str] = []
-    for label in CLASS_SLUGS:
-        patients = by_class.get(label)
+    # グループを固定の順（ALL_DIR_NAMES）で処理し，乱数の消費順を入力に依存させない．
+    for group in ALL_DIR_NAMES:
+        patients = by_group.get(group)
         if not patients:
             continue
         shuffled = [patients[i] for i in rng.permutation(len(patients))]
@@ -125,13 +181,13 @@
         n_val = _round_half_up(len(patients) * val_ratio)
         if n_test + n_val >= len(patients):
             raise ValueError(
-                f"クラス {label} の患者 {len(patients)} 人では train に患者が残らない"
+                f"グループ {group} の患者 {len(patients)} 人では train に患者が残らない"
                 f"（val {n_val} 人・test {n_test} 人）"
             )
         if n_test == 0 or n_val == 0:
             logger.warning(
-                "クラス %s は患者 %d 人のため val %d 人・test %d 人になった",
-                label,
+                "グループ %s は患者 %d 人のため val %d 人・test %d 人になった",
+                group,
                 len(patients),
                 n_val,
                 n_test,
@@ -154,13 +210,14 @@
 
 
 def make_kfold_splits(records: Sequence[ManifestRecord], n_folds: int, seed: int) -> list[Fold]:
-    """患者単位・クラス層化の K-fold 交差検証の分割を作る.
+    """患者単位・クラス × 程度の層化の K-fold 交差検証の分割を作る.
 
-    患者の一覧（患者 ID 昇順）を label で層化して `StratifiedKFold` にかける．
-    各患者はちょうど 1 つの fold の `held_out` に入る．
+    患者の一覧（患者 ID 昇順）を層化グループ（`<label>_<severity>`．`patient_groups`）で
+    層化して `StratifiedKFold` にかける．各患者はちょうど 1 つの fold の `held_out` に入る．
+    `data.severities` による除外はここでは行わない（分割後に `split_records` で適用する）．
 
     Args:
-        records: manifest レコード（検証済み）．
+        records: manifest レコード（検証済み．除外前の全体）．
         n_folds: fold 数（2 以上）．
         seed: 乱数 seed．
 
@@ -169,21 +226,21 @@
 
     Raises:
         ValueError: fold 数が不正，レコードが空，同一患者に異なる label がある，
-            またはあるクラスの患者数が fold 数より少ない場合．
+            またはある層化グループの患者数が fold 数より少ない場合．
     """
     if n_folds < 2:
         raise ValueError(f"fold 数は 2 以上でなければならない（現在 {n_folds}）")
-    by_class = _patients_by_class(records)
-    for label, patients in by_class.items():
-        # 患者数が fold 数未満のクラスは，held_out に現れない fold ができ評価が歪むため止める．
+    by_group = _patients_by_group(records)
+    for group, patients in by_group.items():
+        # 患者数が fold 数未満のグループは，held_out に現れない fold ができ評価が歪むため止める．
         if len(patients) < n_folds:
             raise ValueError(
-                f"クラス {label} の患者数 {len(patients)} 人が fold 数 {n_folds} より少ない"
+                f"グループ {group} の患者数 {len(patients)} 人が fold 数 {n_folds} より少ない"
             )
 
-    labels_of = patient_labels(records)
-    patient_ids = sorted(labels_of)
-    y = np.array([labels_of[p] for p in patient_ids])
+    groups_of = patient_groups(records)
+    patient_ids = sorted(groups_of)
+    y = np.array([groups_of[p] for p in patient_ids])
     splitter = StratifiedKFold(n_splits=n_folds, shuffle=True, random_state=seed)
 
     folds: list[Fold] = []
@@ -220,6 +277,61 @@
     return [r for r in records if r.patient_id in wanted]
 
 
+def filter_by_severity(
+    records: Iterable[ManifestRecord], severities: Collection[str]
+) -> list[ManifestRecord]:
+    """指定した程度の画像だけを残す（入力の順序を保つ）.
+
+    除外は画像（レコード）単位で行う．1 患者複数枚で程度が混在する場合は，その患者の
+    該当しない画像だけが除かれる．
+
+    Args:
+        records: manifest レコード．
+        severities: 残す程度（`strong`・`mild`・`normal` の空でない部分集合）．
+
+    Returns:
+        該当するレコード．
+
+    Raises:
+        ValueError: `severities` が空，または未知の値を含む場合．
+    """
+    wanted = _check_severities(severities)
+    return [r for r in records if r.severity in wanted]
+
+
+def split_records(
+    records: Sequence[ManifestRecord],
+    split: SplitResult | Fold,
+    severities: Collection[str] | None = None,
+) -> dict[str, list[ManifestRecord]]:
+    """分割結果（患者 ID）を各分割のレコードに展開し，程度による除外を適用する.
+
+    分割は manifest 全体で行い，`data.severities` はこの関数で**分割の後に**適用する
+    （SPEC_02「程度（ややあり）の扱い」）．こうすると，同じ seed の分割から作った
+    「ややあり除外」の各分割は「ややあり込み」の各分割の部分集合になる．
+
+    Args:
+        records: 分割に使った manifest レコード（除外前の全体）．
+        split: 単一分割の結果，または K-fold の 1 fold．
+        severities: 残す程度．None なら除外しない．
+
+    Returns:
+        分割名（単一分割は `train`・`val`・`test`，fold は `train`・`held_out`）→
+        その分割のレコード（入力の順序を保つ）．
+
+    Raises:
+        ValueError: `severities` が空，または未知の値を含む場合．
+    """
+    wanted = None if severities is None else _check_severities(severities)
+    result: dict[str, list[ManifestRecord]] = {}
+    for name, patient_ids in split.parts().items():
+        selected = select_records(records, patient_ids)
+        if wanted is not None:
+            selected = [r for r in selected if r.severity in wanted]
+        result[name] = selected
+    return result
+
+
 def count_by_class(records: Iterable[ManifestRecord]) -> dict[str, int]:
     """クラスごとの画像枚数を数える.
 
@@ -247,16 +359,43 @@
     return dict(sorted(counts.items(), key=lambda kv: (order[kv[0][0]], kv[0][1])))
 
 
-def _patients_by_class(records: Sequence[ManifestRecord]) -> dict[str, list[str]]:
+def count_by_group(records: Iterable[ManifestRecord]) -> dict[str, int]:
+    """層化グループ（`<label>_<severity>`）ごとの画像枚数を数える.
+
+    Args:
+        records: manifest レコード．
+
+    Returns:
+        グループ名 → 枚数（有効な 9 グループをすべて `ALL_DIR_NAMES` の順に含み，
+        無いものは 0）．
+    """
+    counts = Counter(record_group(r) for r in records)
+    return {group: counts.get(group, 0) for group in ALL_DIR_NAMES}
+
+
+def _check_severities(severities: Collection[str]) -> frozenset[str]:
+    # 設定は schema で検証済みだが，関数を直接呼んだときに空集合で全件が消えるのを防ぐ．
+    if not severities:
+        raise ValueError("残す程度が空である（strong・mild・normal から 1 つ以上）")
+    unknown = sorted(set(severities) - set(SEVERITIES))
+    if unknown:
+        raise ValueError(f"未知の程度がある: {', '.join(map(repr, unknown))}")
+    return frozenset(severities)
+
+
+def _patients_by_group(records: Sequence[ManifestRecord]) -> dict[str, list[str]]:
     if not records:
         raise ValueError("分割対象のレコードが 0 件である")
-    by_class: dict[str, list[str]] = {}
-    for patient_id, label in patient_labels(records).items():
-        if label not in CLASS_SLUGS:
-            raise ValueError(f"未知の label がある: {label!r}（manifest の検証を通すこと）")
-        by_class.setdefault(label, []).append(patient_id)
+    by_group: dict[str, list[str]] = {}
+    for patient_id, group in patient_groups(records).items():
+        if group not in ALL_DIR_NAMES:
+            raise ValueError(
+                f"無効な label と severity の組み合わせがある: {group!r}"
+                "（manifest の検証を通すこと）"
+            )
+        by_group.setdefault(group, []).append(patient_id)
     # 入力順に依存させず決定的にするため，患者 ID でソートしておく．
-    return {label: sorted(patients) for label, patients in by_class.items()}
+    return {group: sorted(patients) for group, patients in by_group.items()}
 
 
 def _round_half_up(value: float) -> int:
diff --git a/src/tias_judge_model/data/survey.py b/src/tias_judge_model/data/survey.py
new file mode 100644
index 0000000..b7dc73d
--- /dev/null
+++ b/src/tias_judge_model/data/survey.py
@@ -0,0 +1,512 @@
+"""データセット集計（`tias-dataset survey` の計算部分）.
+
+集計項目は SPEC_01「データセット集計の出力」に従う．画像の読み込み（`read_image_stats`・
+`collect_image_stats`）と，読み込み結果からの集計（`summarize_dataset`．純関数）を分けている．
+
+**出力には集計値だけを入れる**．画像単位の値・患者 ID・ファイル名は結果にもログにも出さない
+（CLAUDE.md 必須ルール）．`ImageStats` は画像単位の値を持つため，関数の外（ファイル・ログ）へ
+そのまま出さないこと．
+"""
+
+from __future__ import annotations
+
+import logging
+import math
+from collections import Counter
+from collections.abc import Callable, Iterable, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+from PIL import Image
+
+from tias_judge_model.data.classes import ALL_DIR_NAMES, CLASS_SLUGS, SEVERITIES, parse_dir_name
+from tias_judge_model.data.color import delta_e_cie76, mean_tongue_lab, tongue_mask
+from tias_judge_model.data.manifest import ManifestRecord, resolve_image_path
+from tias_judge_model.data.split import (
+    Fold,
+    SplitResult,
+    count_by_class,
+    count_by_group,
+    make_kfold_splits,
+    record_group,
+    split_records,
+    split_train_val_test,
+)
+
+logger = logging.getLogger(__name__)
+
+SUMMARY_SCHEMA_VERSION = 1
+
+# 「ややあり」を入れる／入れない実験の 2 条件（SPEC_02「程度（ややあり）の扱い」）．
+SEVERITY_CONDITIONS: dict[str, tuple[str, ...]] = {
+    "with_mild": ("strong", "mild", "normal"),
+    "without_mild": ("strong", "normal"),
+}
+
+# mild グループと比べる「淡紅（正常）」のグループ．
+NORMAL_GROUP = "light_red_normal"
+
+LAB_CHANNELS: tuple[str, ...] = ("L", "a", "b")
+
+_PROGRESS_EVERY = 100
+_ROUND_DIGITS = 4
+
+
+@dataclass(frozen=True)
+class ImageStats:
+    """1 枚の画像から測った値（集計の入力．**ファイル・ログへそのまま出さない**）.
+
+    Attributes:
+        readable: 画像として読めたか．
+        missing: ファイルが存在しなかったか（`readable` が False のときのみ意味を持つ）．
+        mode: PIL の画像モード（例: `"RGB"`）．読めなければ None．
+        has_alpha: アルファチャンネル（透過情報）を持つか．
+        width: 幅（px）．読めなければ 0．
+        height: 高さ（px）．読めなければ 0．
+        tongue_ratio: 画像に占める舌領域（背景でない画素）の割合．読めなければ None．
+        lab: 舌領域の平均 L*・a*・b*．読めない，または舌領域が無ければ None．
+    """
+
+    readable: bool
+    missing: bool = False
+    mode: str | None = None
+    has_alpha: bool = False
+    width: int = 0
+    height: int = 0
+    tongue_ratio: float | None = None
+    lab: tuple[float, float, float] | None = None
+
+
+def measure_pixels(pixels: np.ndarray, *, mode: str, has_alpha: bool) -> ImageStats:
+    """RGB 画素から画像 1 枚の値を測る.
+
+    Args:
+        pixels: RGB 画像（`(H, W, 3)`, uint8）．
+        mode: 元の画像モード（記録用）．
+        has_alpha: 元の画像がアルファチャンネルを持つか（記録用）．
+
+    Returns:
+        測定値．
+
+    Raises:
+        ValueError: `pixels` の形状が `(H, W, 3)` でない場合．
+    """
+    arr = np.asarray(pixels)
+    if arr.ndim != 3 or arr.shape[2] != 3:
+        raise ValueError(f"画素の形状は (H, W, 3) でなければならない（{arr.shape}）")
+    height, width = arr.shape[:2]
+    mask = tongue_mask(arr)
+    ratio = float(mask.mean()) if mask.size else 0.0
+    lab = mean_tongue_lab(arr)
+    return ImageStats(
+        readable=True,
+        mode=mode,
+        has_alpha=has_alpha,
+        width=int(width),
+        height=int(height),
+        tongue_ratio=ratio,
+        lab=None if lab is None else (float(lab[0]), float(lab[1]), float(lab[2])),
+    )
+
+
+def read_image_stats(path: Path) -> ImageStats:
+    """画像ファイルを読んで値を測る（読めなければ `readable=False` を返し，止めない）.
+
+    集計は現状把握のためであり，学習時の fail fast とは目的が異なるため，読めない画像は
+    件数として数えるだけにする（SPEC_01「データセット集計の出力」）．
+
+    Args:
+        path: 画像ファイルのパス．
+
+    Returns:
+        測定値．
+    """
+    if not path.is_file():
+        return ImageStats(readable=False, missing=True)
+    try:
+        with Image.open(path) as img:
+            img.load()
+            mode = img.mode
+            has_alpha = "A" in img.getbands() or "transparency" in img.info
+            rgb = img if mode == "RGB" else img.convert("RGB")
+            pixels = np.asarray(rgb, dtype=np.uint8)  # (H, W, 3)
+    except (OSError, ValueError, Image.DecompressionBombError):
+        # 破損・非対応形式・巨大すぎる画像．どの画像かはログに出さない（ファイル名を出さないため）．
+        return ImageStats(readable=False)
+    return measure_pixels(pixels, mode=mode, has_alpha=has_alpha)
+
+
+def collect_image_stats(
+    records: Sequence[ManifestRecord],
+    images_dir: Path,
+    reader: Callable[[Path], ImageStats] = read_image_stats,
+) -> list[ImageStats]:
+    """manifest の全画像を読んで値を測る（進捗は件数だけをログに出す）.
+
+    Args:
+        records: manifest レコード．
+        images_dir: 画像ディレクトリ（`<data_root>/images`）．
+        reader: 1 枚を測る関数（テストで差し替えるため）．
+
+    Returns:
+        `records` と同じ順の測定値．
+    """
+    stats: list[ImageStats] = []
+    total = len(records)
+    for i, record in enumerate(records, start=1):
+        stats.append(reader(resolve_image_path(images_dir, record)))
+        if i % _PROGRESS_EVERY == 0 or i == total:
+            logger.info("画像を読んだ: %d / %d 件", i, total)
+    unreadable = sum(1 for s in stats if not s.readable)
+    if unreadable:
+        logger.warning("読めなかった画像が %d 件ある（集計からは除いて続行する）", unreadable)
+    return stats
+
+
+def lab_values_by_group(
+    records: Sequence[ManifestRecord], stats: Sequence[ImageStats]
+) -> dict[str, np.ndarray]:
+    """グループごとに，画像ごとの舌領域の平均 Lab を集める（図の描画用）.
+
+    Args:
+        records: manifest レコード．
+        stats: `records` と同じ順の測定値．
+
+    Returns:
+        グループ名（`ALL_DIR_NAMES` の順）→ 平均 Lab の配列（`(N, 3)`, float64．N は
+        Lab が得られた画像数で 0 もありうる）．
+
+    Raises:
+        ValueError: `records` と `stats` の長さが異なる場合．
+    """
+    _check_same_length(records, stats)
+    values: dict[str, list[tuple[float, float, float]]] = {g: [] for g in ALL_DIR_NAMES}
+    for record, stat in zip(records, stats, strict=True):
+        if stat.lab is not None:
+            values[record_group(record)].append(stat.lab)
+    return {g: np.array(v, dtype=np.float64).reshape(-1, 3) for g, v in values.items()}
+
+
+def summarize_dataset(
+    records: Sequence[ManifestRecord],
+    stats: Sequence[ImageStats],
+    *,
+    seed: int,
+    val_ratio: float,
+    test_ratio: float,
+    n_folds: int,
+    configured_severities: Iterable[str],
+) -> dict[str, Any]:
+    """データセットの集計値を計算する（JSON にできる dict を返す純関数）.
+
+    結果には集計値だけを入れ，画像単位の値・患者 ID・ファイル名は入れない．
+
+    Args:
+        records: manifest レコード（検証済み．除外前の全体）．
+        stats: `records` と同じ順の測定値．
+        seed: 分割の seed．
+        val_ratio: 単一分割の val の比率．
+        test_ratio: 単一分割の test の比率．
+        n_folds: 交差検証の fold 数．
+        configured_severities: 設定の `data.severities`（記録用）．
+
+    Returns:
+        集計結果（キーは `counts`・`loading`・`size`・`tongue_ratio`・`lab`・`delta_e`・
+        `split` 等．構造は SPEC_01「データセット集計の出力」）．
+
+    Raises:
+        ValueError: `records` と `stats` の長さが異なる場合．
+    """
+    _check_same_length(records, stats)
+    lab_by_group = lab_values_by_group(records, stats)
+    lab_summary = _lab_summary(records, stats, lab_by_group)
+    return {
+        "schema_version": SUMMARY_SCHEMA_VERSION,
+        "configured_severities": list(configured_severities),
+        "counts": _count_summary(records),
+        "loading": _loading_summary(records, stats),
+        "size": _size_summary(stats),
+        "tongue_ratio": _tongue_ratio_summary(records, stats),
+        "lab": lab_summary,
+        "delta_e": _delta_e_summary(lab_by_group),
+        "split": _split_summary(
+            records, seed=seed, val_ratio=val_ratio, test_ratio=test_ratio, n_folds=n_folds
+        ),
+    }
+
+
+# ---------------------------------------------------------------------------
+# 件数
+# ---------------------------------------------------------------------------
+
+
+def _count_summary(records: Sequence[ManifestRecord]) -> dict[str, Any]:
+    def images_patients(rs: Iterable[ManifestRecord]) -> dict[str, int]:
+        rs = list(rs)
+        return {"images": len(rs), "patients": len({r.patient_id for r in rs})}
+
+    groups: dict[str, Any] = {}
+    for group in ALL_DIR_NAMES:
+        label, severity = parse_dir_name(group)
+        groups[group] = {
+            "label": label,
+            "severity": severity,
+            **images_patients(r for r in records if record_group(r) == group),
+        }
+    conditions: dict[str, Any] = {}
+    for name, severities in SEVERITY_CONDITIONS.items():
+        kept = [r for r in records if r.severity in severities]
+        conditions[name] = {
+            "severities": list(severities),
+            **images_patients(kept),
+            "classes": count_by_class(kept),
+        }
+    return {
+        "total": images_patients(records),
+        "groups": groups,
+        "classes": {c: images_patients(r for r in records if r.label == c) for c in CLASS_SLUGS},
+        "severities": {
+            s: images_patients(r for r in records if r.severity == s) for s in SEVERITIES
+        },
+        "conditions": conditions,
+    }
+
+
+# ---------------------------------------------------------------------------
+# 読み込み・サイズ・舌領域の割合
+# ---------------------------------------------------------------------------
+
+
+def _loading_summary(
+    records: Sequence[ManifestRecord], stats: Sequence[ImageStats]
+) -> dict[str, Any]:
+    readable = [s for s in stats if s.readable]
+    unreadable_by_group = Counter(
+        record_group(r) for r, s in zip(records, stats, strict=True) if not s.readable
+    )
+    modes = Counter(s.mode for s in readable)
+    return {
+        "readable": len(readable),
+        "unreadable": len(stats) - len(readable),
+        "missing": sum(1 for s in stats if not s.readable and s.missing),
+        "unreadable_by_group": {g: unreadable_by_group.get(g, 0) for g in ALL_DIR_NAMES},
+        "modes": dict(sorted(modes.items())),
+        "non_rgb_mode": sum(1 for s in readable if s.mode != "RGB"),
+        "with_alpha": sum(1 for s in readable if s.has_alpha),
+        "no_tongue_pixels": sum(1 for s in readable if s.lab is None),
+    }
+
+
+def _size_summary(stats: Sequence[ImageStats]) -> dict[str, Any]:
+    readable = [s for s in stats if s.readable]
+    return {
+        "width": _min_max_mean_median([s.width for s in readable]),
+        "height": _min_max_mean_median([s.height for s in readable]),
+    }
+
+
+def _tongue_ratio_summary(
+    records: Sequence[ManifestRecord], stats: Sequence[ImageStats]
+) -> dict[str, Any]:
+    by_group: dict[str, list[float]] = {g: [] for g in ALL_DIR_NAMES}
+    for record, stat in zip(records, stats, strict=True):
+        if stat.tongue_ratio is not None:
+            by_group[record_group(record)].append(stat.tongue_ratio)
+    all_values = [v for values in by_group.values() for v in values]
+    return {
+        "total": _min_mean_max(all_values),
+        "groups": {g: _min_mean_max(v) for g, v in by_group.items()},
+    }
+
+
+# ---------------------------------------------------------------------------
+# 色（Lab）と色差
+# ---------------------------------------------------------------------------
+
+
+def _lab_summary(
+    records: Sequence[ManifestRecord],
+    stats: Sequence[ImageStats],
+    lab_by_group: dict[str, np.ndarray],
+) -> dict[str, Any]:
+    by_class: dict[str, list[tuple[float, float, float]]] = {c: [] for c in CLASS_SLUGS}
+    for record, stat in zip(records, stats, strict=True):
+        if stat.lab is not None:
+            by_class[record.label].append(stat.lab)
+    all_values = np.concatenate(list(lab_by_group.values()), axis=0)
+    return {
+        "method": (
+            "画像ごとに舌領域（RGB がすべて 0 でない画素）の L*a*b*（sRGB→XYZ D65→Lab D65）を"
+            "平均し，その値をグループ・クラス・全体で集計した"
+        ),
+        "groups": {g: _lab_stats(v) for g, v in lab_by_group.items()},
+        "classes": {
+            c: _lab_stats(np.array(v, dtype=np.float64).reshape(-1, 3)) for c, v in by_class.items()
+        },
+        "total": _lab_stats(all_values),
+    }
+
+
+def _lab_stats(values: np.ndarray) -> dict[str, Any]:
+    """平均 Lab の配列（`(N, 3)`）からチャンネルごとの統計を作る（N = 0 なら値は None）."""
+    result: dict[str, Any] = {"n": int(values.shape[0])}
+    for i, channel in enumerate(LAB_CHANNELS):
+        result[channel] = _distribution(values[:, i])
+    return result
+
+
+def _distribution(values: np.ndarray) -> dict[str, float | None]:
+    if values.size == 0:
+        return dict.fromkeys(("mean", "std", "median", "p10", "p90"))
+    # 標本標準偏差（ddof=1）．1 件しかなければ求められないため None．
+    std = float(np.std(values, ddof=1)) if values.size > 1 else None
+    return {
+        "mean": _round(float(np.mean(values))),
+        "std": _round(std),
+        "median": _round(float(np.median(values))),
+        "p10": _round(float(np.percentile(values, 10))),
+        "p90": _round(float(np.percentile(values, 90))),
+    }
+
+
+def _delta_e_summary(lab_by_group: dict[str, np.ndarray]) -> dict[str, Any]:
+    # 丸める前の平均から求める（丸め誤差を色差に持ち込まないため）．
+    means = {g: (v.mean(axis=0) if v.shape[0] else None) for g, v in lab_by_group.items()}
+
+    def delta(g1: str, g2: str) -> float | None:
+        m1, m2 = means.get(g1), means.get(g2)
+        if m1 is None or m2 is None:
+            return None
+        return _round(delta_e_cie76(m1, m2))
+
+    matrix = {g1: {g2: delta(g1, g2) for g2 in ALL_DIR_NAMES} for g1 in ALL_DIR_NAMES}
+    mild_comparison = []
+    for group in ALL_DIR_NAMES:
+        label, severity = parse_dir_name(group)
+        if severity != "mild":
+            continue
+        strong_group = f"{label}_strong"
+        to_normal = delta(group, NORMAL_GROUP)
+        to_strong = delta(group, strong_group)
+        closer: str | None
+        if to_normal is None or to_strong is None:
+            closer = None
+        elif to_normal < to_strong:
+            closer = NORMAL_GROUP
+        elif to_strong < to_normal:
+            closer = strong_group
+        else:
+            closer = "tie"
+        mild_comparison.append(
+            {
+                "group": group,
+                "normal_group": NORMAL_GROUP,
+                "delta_e_to_normal": to_normal,
+                "strong_group": strong_group,
+                "delta_e_to_strong": to_strong,
+                "closer_to": closer,
+            }
+        )
+    return {
+        "method": "CIE76（グループの平均 Lab どうしのユークリッド距離）",
+        "mild_comparison": mild_comparison,
+        "matrix": matrix,
+    }
+
+
+# ---------------------------------------------------------------------------
+# 分割の確認
+# ---------------------------------------------------------------------------
+
+
+def _split_summary(
+    records: Sequence[ManifestRecord],
+    *,
+    seed: int,
+    val_ratio: float,
+    test_ratio: float,
+    n_folds: int,
+) -> dict[str, Any]:
+    result: dict[str, Any] = {
+        "seed": seed,
+        "val_ratio": val_ratio,
+        "test_ratio": test_ratio,
+        "n_folds": n_folds,
+    }
+    # 分割できない構成でも集計自体は現状把握として役に立つため，理由を記録して続ける
+    # （メッセージはグループ名と人数のみで，患者 ID を含まない）．
+    try:
+        single = split_train_val_test(
+            records, val_ratio=val_ratio, test_ratio=test_ratio, seed=seed
+        )
+    except ValueError as exc:
+        result["single"] = {"error": str(exc)}
+    else:
+        result["single"] = _parts_summary(records, single)
+    try:
+        folds = make_kfold_splits(records, n_folds=n_folds, seed=seed)
+    except ValueError as exc:
+        result["kfold"] = {"error": str(exc)}
+    else:
+        result["kfold"] = [{"index": fold.index, **_parts_summary(records, fold)} for fold in folds]
+    return result
+
+
+def _parts_summary(records: Sequence[ManifestRecord], split: SplitResult | Fold) -> dict[str, Any]:
+    everything = split_records(records, split)
+    by_condition = {
+        name: split_records(records, split, severities)
+        for name, severities in SEVERITY_CONDITIONS.items()
+    }
+    return {
+        "groups": {part: count_by_group(rs) for part, rs in everything.items()},
+        "patients": {part: len({r.patient_id for r in rs}) for part, rs in everything.items()},
+        "conditions": {
+            name: {
+                part: {"images": len(rs), "classes": count_by_class(rs)}
+                for part, rs in parts.items()
+            }
+            for name, parts in by_condition.items()
+        },
+    }
+
+
+# ---------------------------------------------------------------------------
+# 補助
+# ---------------------------------------------------------------------------
+
+
+def _check_same_length(records: Sequence[ManifestRecord], stats: Sequence[ImageStats]) -> None:
+    if len(records) != len(stats):
+        raise ValueError(f"レコード数 {len(records)} 件と測定値の数 {len(stats)} 件が一致しない")
+
+
+def _min_max_mean_median(values: Sequence[float]) -> dict[str, float | None]:
+    if not values:
+        return dict.fromkeys(("min", "max", "mean", "median"))
+    arr = np.asarray(values, dtype=np.float64)
+    return {
+        "min": _round(float(arr.min())),
+        "max": _round(float(arr.max())),
+        "mean": _round(float(arr.mean())),
+        "median": _round(float(np.median(arr))),
+    }
+
+
+def _min_mean_max(values: Sequence[float]) -> dict[str, float | None]:
+    if not values:
+        return dict.fromkeys(("min", "mean", "max"))
+    arr = np.asarray(values, dtype=np.float64)
+    return {
+        "min": _round(float(arr.min())),
+        "mean": _round(float(arr.mean())),
+        "max": _round(float(arr.max())),
+    }
+
+
+def _round(value: float | None) -> float | None:
+    if value is None or not math.isfinite(value):
+        return None
+    return round(value, _ROUND_DIGITS)
diff --git a/src/tias_judge_model/data/survey_figures.py b/src/tias_judge_model/data/survey_figures.py
new file mode 100644
index 0000000..46b6f0b
--- /dev/null
+++ b/src/tias_judge_model/data/survey_figures.py
@@ -0,0 +1,124 @@
+"""データセット集計の図（グループごとの Lab 分布・グループ平均の a*-b* 平面）.
+
+`figures/` は回収ホワイトリストの対象であるため，**集計値の図だけ**を描き，画像そのもの・
+切り出しは描かない（SPEC_01「実験の出力」）．個々の画像の値が点として現れないよう，
+箱ひげ図は外れ値の点を描かず，ひげを 10/90 パーセンタイルにする（`dataset_summary.json` の
+p10・p90 と一致する）．
+
+pyplot を使わず `matplotlib.figure.Figure` を直接使う（GUI バックエンドを選ばず Agg で描くため．
+サーバには表示環境が無い）．ラベルは日本語フォントの有無に左右されないよう英字 slug で書く．
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from pathlib import Path
+
+import numpy as np
+from matplotlib.backends.backend_agg import FigureCanvasAgg
+from matplotlib.figure import Figure
+
+from tias_judge_model.data.classes import ALL_DIR_NAMES, parse_dir_name
+
+LAB_BOXPLOT_FILENAME = "lab_by_group.png"
+LAB_MEANS_AB_FILENAME = "lab_group_means_ab.png"
+
+_CHANNEL_TITLES: tuple[str, ...] = ("L*", "a*", "b*")
+_WHISKER_PERCENTILES = (10.0, 90.0)
+_DPI = 120
+# 程度ごとの目印（同じクラスの strong と mild を同じ色で並べ，形で見分ける）．
+_SEVERITY_MARKERS: dict[str, str] = {"strong": "o", "mild": "^", "normal": "s"}
+_CLASS_COLORS: dict[str, str] = {
+    "pale": "#c9a0a0",
+    "light_red": "#e07b7b",
+    "red": "#d62728",
+    "dark_red": "#7f1d1d",
+    "purple": "#7b3fa0",
+}
+
+
+def plot_lab_by_group(lab_by_group: Mapping[str, np.ndarray], path: Path) -> None:
+    """グループごとの L*・a*・b* の分布を箱ひげ図で描いて PNG に保存する.
+
+    Args:
+        lab_by_group: グループ名 → 画像ごとの舌領域の平均 Lab（`(N, 3)`, float64）．
+        path: 出力先の PNG パス．親ディレクトリは作成される．
+    """
+    groups = [g for g in ALL_DIR_NAMES if g in lab_by_group]
+    fig = Figure(figsize=(12, 10), dpi=_DPI)
+    FigureCanvasAgg(fig)
+    axes = fig.subplots(3, 1, sharex=True)
+    for channel, (ax, title) in enumerate(zip(axes, _CHANNEL_TITLES, strict=True)):
+        data = [lab_by_group[g][:, channel] for g in groups]
+        positions = [i for i, d in enumerate(data) if d.size > 0]
+        if positions:
+            ax.boxplot(
+                [data[i] for i in positions],
+                positions=positions,
+                whis=_WHISKER_PERCENTILES,
+                showfliers=False,
+                showmeans=True,
+                widths=0.6,
+            )
+        counts = [d.size for d in data]
+        ax.set_xticks(range(len(groups)))
+        ax.set_xticklabels(
+            [f"{g}\n(n={n})" for g, n in zip(groups, counts, strict=True)], fontsize=8
+        )
+        ax.set_xlim(-0.6, len(groups) - 0.4)
+        ax.set_ylabel(title)
+        ax.grid(axis="y", alpha=0.3)
+    axes[0].set_title(
+        "Per-image mean Lab of tongue region by group "
+        "(box: quartiles, whiskers: 10-90th pct, triangle: mean)"
+    )
+    _save(fig, path)
+
+
+def plot_group_means_ab(
+    group_means: Mapping[str, Sequence[float] | None],
+    group_stds: Mapping[str, Sequence[float] | None],
+    path: Path,
+) -> None:
+    """グループ平均の a*-b* 平面の図（標準偏差のエラーバー付き）を PNG に保存する.
+
+    mild グループが淡紅（`light_red_normal`）と同じクラスの strong のどちらに近いかを
+    目で確かめるための図．
+
+    Args:
+        group_means: グループ名 → 平均 (L*, a*, b*)（無ければ None）．
+        group_stds: グループ名 → 標準偏差 (L*, a*, b*)（無ければ None．要素が None でもよい）．
+        path: 出力先の PNG パス．親ディレクトリは作成される．
+    """
+    fig = Figure(figsize=(8, 7), dpi=_DPI)
+    FigureCanvasAgg(fig)
+    ax = fig.subplots()
+    for group in ALL_DIR_NAMES:
+        mean = group_means.get(group)
+        if mean is None:
+            continue
+        label, severity = parse_dir_name(group)
+        std = group_stds.get(group) or (None, None, None)
+        ax.errorbar(
+            mean[1],
+            mean[2],
+            xerr=std[1] if std[1] is not None else None,
+            yerr=std[2] if std[2] is not None else None,
+            fmt=_SEVERITY_MARKERS[severity],
+            color=_CLASS_COLORS[label],
+            markersize=9,
+            capsize=3,
+            label=group,
+        )
+    ax.set_xlabel("a* (group mean, error bar: std)")
+    ax.set_ylabel("b* (group mean, error bar: std)")
+    ax.set_title("Group means on the a*-b* plane (o: strong, ^: mild, s: normal)")
+    ax.grid(alpha=0.3)
+    ax.legend(fontsize=8, loc="best")
+    _save(fig, path)
+
+
+def _save(fig: Figure, path: Path) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    fig.tight_layout()
+    fig.savefig(path, format="png")
diff --git a/src/tias_judge_model/remote/commands.py b/src/tias_judge_model/remote/commands.py
index cb81044..bdc3174 100644
--- a/src/tias_judge_model/remote/commands.py
+++ b/src/tias_judge_model/remote/commands.py
@@ -16,7 +16,7 @@
 import shlex
 from collections.abc import Mapping, Sequence
 
-from tias_judge_model.schema import DATA_ROOT_ENV_VAR
+from tias_judge_model.schema import DATA_ROOT_ENV_VAR, GIT_COMMIT_ENV_VAR
 
 REMOTE_RUNS_DIR = "runs"
 REMOTE_LOG_DIR = f"{REMOTE_RUNS_DIR}/_remote_logs"
@@ -62,9 +62,15 @@
 # ssh の接続先（ユーザー名・アドレス・踏み台）に許す文字．空白や `-` 始まりでオプションとして
 # 解釈されるのを防ぐ
 _SSH_TOKEN_RE = re.compile(r"^[A-Za-z0-9_.][A-Za-z0-9_.@:%-]*$")
+# git rev-parse --short HEAD の出力（16 進）．実験 ID に埋め込むため，これ以外は渡さない
+_GIT_SHORT_HASH_RE = re.compile(r"^[0-9a-f]{4,40}$")
+GIT_DIRTY_SUFFIX = "-dirty"
 
 _NOW = "\"$(date '+%Y-%m-%d %H:%M:%S')\""
 
+# GPU を使わないジョブ（run --cpu）のログの開始行に書く GPU 欄（SPEC_03「run」）
+NO_GPU_LABEL = "なし（CPU）"
+
 
 def quote_remote_path(path: str) -> str:
     """リモートのパスをシェル用にクォートする.
@@ -167,17 +173,41 @@
     return key, value
 
 
-def build_job_env(gpu_index: int, extra: Sequence[str]) -> dict[str, str]:
+def format_git_commit(short_hash: str, *, dirty: bool) -> str | None:
+    """`TIAS_GIT_COMMIT` に渡す値（git の短縮ハッシュ，未コミットの変更があれば `-dirty` 付き）.
+
+    Args:
+        short_hash: `git rev-parse --short HEAD` の出力（前後の空白は無視する）．
+        dirty: 未コミットの変更があるか（`git status --porcelain` の出力が空でないか）．
+
+    Returns:
+        渡す値．`short_hash` が短縮ハッシュの形式でなければ None（渡さない）．
+    """
+    value = short_hash.strip()
+    if not _GIT_SHORT_HASH_RE.match(value):
+        return None
+    return value + GIT_DIRTY_SUFFIX if dirty else value
+
+
+def build_job_env(
+    gpu_index: int | None, extra: Sequence[str], *, git_commit: str | None = None
+) -> dict[str, str]:
     """ジョブに渡す環境変数（値をそのまま渡すもの）を組み立てる.
 
     `CUDA_DEVICE_ORDER=PCI_BUS_ID` を付けるのは，CUDA の既定の番号付け（速い順）が
     nvidia-smi の index（PCI バス順）と異なりうるため（異なると空きと判定した GPU とは別の
     GPU を使ってしまう）．`TIAS_DATA_ROOT` はパスとして別に渡す（`build_job_script` の
-    `path_env`）．GPU の割り当てを迂回させないため，`--env` で予約済みの変数は上書きできない．
+    `path_env`）．`TIAS_GIT_COMMIT` はサーバに `.git` を送らないため手元で求めて渡す
+    （実験 ID に使う．SPEC_01「実験の出力」）．GPU の割り当てと実験の記録を迂回させないため，
+    `--env` で予約済みの変数は上書きできない（`TIAS_GIT_COMMIT` は git が使えず渡さない
+    ときも予約済み）．
+    GPU を使わないジョブ（`run --cpu`）では `CUDA_VISIBLE_DEVICES` を空文字で渡し，
+    CUDA から GPU が見えないようにする（誤って GPU を掴まないため）．
 
     Args:
-        gpu_index: 選んだ GPU の番号（nvidia-smi の index）．
+        gpu_index: 選んだ GPU の番号（nvidia-smi の index）．None なら GPU を使わない（`--cpu`）．
         extra: `--env` で指定された `KEY=VALUE`（後勝ち）．
+        git_commit: `TIAS_GIT_COMMIT` に渡す値（`format_git_commit` の結果）．None なら渡さない．
 
     Returns:
         環境変数の辞書（挿入順＝ログに表示する順）．
@@ -185,15 +215,17 @@
     Raises:
         ValueError: GPU 番号が負，`KEY=VALUE` が不正，または予約済みの変数を指定した場合．
     """
-    if gpu_index < 0:
+    if gpu_index is not None and gpu_index < 0:
         raise ValueError(f"GPU 番号は 0 以上: {gpu_index}")
     env = {
         "CUDA_DEVICE_ORDER": "PCI_BUS_ID",
-        "CUDA_VISIBLE_DEVICES": str(gpu_index),
+        "CUDA_VISIBLE_DEVICES": "" if gpu_index is None else str(gpu_index),
         # パイプ越しでも Python の出力がすぐログに出るようにする（既定はブロックバッファ）
         "PYTHONUNBUFFERED": "1",
     }
-    reserved = {*env, DATA_ROOT_ENV_VAR}
+    if git_commit is not None:
+        env[GIT_COMMIT_ENV_VAR] = git_commit
+    reserved = {*env, DATA_ROOT_ENV_VAR, GIT_COMMIT_ENV_VAR}
     for item in extra:
         key, value = parse_env_assignment(item)
         if key in reserved:
@@ -387,7 +419,7 @@
     *,
     uv_path: str,
     server_name: str,
-    gpu_index: int,
+    gpu_index: int | None,
     env: Mapping[str, str],
     path_env: Mapping[str, str],
 ) -> str:
@@ -404,7 +436,8 @@
         command: `uv run` の後ろに付けて実行するコマンドと引数．
         uv_path: リモートの uv 実行ファイル．
         server_name: ログの開始行に書くサーバ名．
-        gpu_index: ログの開始行に書く GPU 番号．
+        gpu_index: ログの開始行に書く GPU 番号．None なら GPU を使わないジョブ（`--cpu`）として
+            `NO_GPU_LABEL` を書く．
         env: ジョブに渡す環境変数（値はそのまま渡す）．
         path_env: ジョブに渡す環境変数のうち，値がリモートのパス（`~` を `$HOME` に展開する）
             であるもの．
@@ -426,7 +459,8 @@
     display = shlex.join(
         [f"{k}={v}" for k, v in [*env.items(), *path_env.items()]] + ["uv", "run", *command]
     )
-    header = f"server={server_name} gpu={gpu_index}"
+    gpu_label = NO_GPU_LABEL if gpu_index is None else str(gpu_index)
+    header = f"server={server_name} gpu={gpu_label}"
     statements = [
         _cd_command(remote_dir),
         f"log={shlex.quote(log)}",
diff --git a/src/tias_judge_model/remote/gpu.py b/src/tias_judge_model/remote/gpu.py
index a8761ae..0e39dc3 100644
--- a/src/tias_judge_model/remote/gpu.py
+++ b/src/tias_judge_model/remote/gpu.py
@@ -516,6 +516,74 @@
         raise ValueError(f"GPU 番号は 0 以上: {gpu_index}")
 
 
+def check_cpu_options(*, gpu_index: int | None, force: bool, observe_sec: int | None) -> None:
+    """`--cpu` と GPU 関連のオプションの組み合わせを検証する（ssh より前に弾くため独立させている）.
+
+    Args:
+        gpu_index: `--gpu` の値．
+        force: `--force` の有無．
+        observe_sec: `--observe` の値．
+
+    Raises:
+        ValueError: `--cpu` と `--gpu`・`--force`・`--observe` のいずれかを同時に指定した場合．
+    """
+    conflicts = [
+        option
+        for option, given in (
+            ("--gpu", gpu_index is not None),
+            ("--force", force),
+            ("--observe", observe_sec is not None),
+        )
+        if given
+    ]
+    if conflicts:
+        raise ValueError(
+            f"--cpu は {'・'.join(conflicts)} と同時に指定できない"
+            "（--cpu では GPU を観測・選択しない）"
+        )
+
+
+def select_cpu_server(
+    probes: Sequence[ServerProbe],
+    *,
+    server_name: str | None = None,
+    include_not_ready: bool = False,
+) -> ServerConfig | None:
+    """`run --cpu`（GPU を使わないジョブ）を実行するサーバを選ぶ（SPEC_03「run」）.
+
+    `server_name` を指定したらそのサーバ．省略時は候補サーバ（`data_ready` のもの．
+    `include_not_ready` なら全サーバ）を priority 昇順（同値は `probes` の順）に見て，最初に
+    接続できたものを選ぶ．GPU の状態は見ない．
+
+    Args:
+        probes: 各サーバの状況（設定の記載順で渡す．同じ priority の順位に使う）．
+        server_name: `--server` の値．
+        include_not_ready: `data_ready: false` のサーバも候補にする（`--no-data`）．
+
+    Returns:
+        選んだサーバ．自動選択で接続できる候補サーバが無ければ None．
+
+    Raises:
+        ValueError: 指定したサーバが設定に無い・データ未配置（`include_not_ready` 無し）・
+            接続不可の場合．
+    """
+    if server_name is not None:
+        probe = _find_probe(probes, server_name)
+        if not probe.server.data_ready and not include_not_ready:
+            raise ValueError(
+                f"{probe.server.name} は臨床データが未配置（data_ready: false）である"
+                "（データを使わないジョブなら --no-data を付ける）"
+            )
+        if not probe.reachable:
+            raise ValueError(f"{probe.server.name} に接続できない（{probe.error}）")
+        return probe.server
+    candidates = sorted(
+        (p for p in probes if p.reachable and (include_not_ready or p.server.data_ready)),
+        key=lambda p: p.server.priority,
+    )
+    return candidates[0].server if candidates else None
+
+
 def select_gpu(
     probes: Sequence[ServerProbe],
     *,
diff --git a/src/tias_judge_model/remote/whitelist.py b/src/tias_judge_model/remote/whitelist.py
index aa2da38..6bcf58b 100644
--- a/src/tias_judge_model/remote/whitelist.py
+++ b/src/tias_judge_model/remote/whitelist.py
@@ -19,7 +19,14 @@
 
 # runs/<RUN_ID>/ 直下で回収するファイル名
 PULL_ROOT_FILES = frozenset(
-    {"config.yaml", "history.csv", "metrics.json", "confusion_matrix.csv", "log.txt"}
+    {
+        "config.yaml",
+        "history.csv",
+        "metrics.json",
+        "confusion_matrix.csv",
+        "log.txt",
+        "dataset_summary.json",
+    }
 )
 PULL_FIGURES_DIR = "figures"
 PULL_FIGURE_SUFFIX = ".png"
diff --git a/src/tias_judge_model/schema.py b/src/tias_judge_model/schema.py
index d5a85fb..f01df80 100644
--- a/src/tias_judge_model/schema.py
+++ b/src/tias_judge_model/schema.py
@@ -13,8 +13,13 @@
 import yaml
 from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
 
+from tias_judge_model.data.classes import SEVERITIES
+
 # データのルートを上書きする環境変数．サーバと手元で YAML を書き換えずに済ませるため．
 DATA_ROOT_ENV_VAR = "TIAS_DATA_ROOT"
+# 実験 ID に入れる git の短縮ハッシュ．サーバには .git を送らないため，tias-remote run が
+# 手元で求めてこの環境変数で渡す（SPEC_01「実験の出力」・SPEC_03「run」）．
+GIT_COMMIT_ENV_VAR = "TIAS_GIT_COMMIT"
 
 
 class _StrictModel(BaseModel):
@@ -30,16 +35,36 @@
         root: データのルートディレクトリ（`images/` と manifest を含む）．`~` は展開される．
             相対パスはカレントディレクトリ基準で解釈する．
         manifest: manifest CSV のパス．相対パスは `root` からの相対として解釈する．
+        severities: 学習・評価に使う程度（`strong`・`mild`・`normal` の部分集合）．
+            分割の後に適用する（SPEC_02「程度（ややあり）の扱い」）．値は `SEVERITIES` の
+            順（strong → mild → normal）にそろえて保持する．
     """
 
     root: Path
     manifest: Path = Path("manifest.csv")
+    severities: tuple[str, ...] = SEVERITIES
 
     @field_validator("root", "manifest", mode="after")
     @classmethod
     def _expand_user(cls, value: Path) -> Path:
         return value.expanduser()
 
+    @field_validator("severities", mode="after")
+    @classmethod
+    def _check_severities(cls, value: tuple[str, ...]) -> tuple[str, ...]:
+        if not value:
+            raise ValueError("data.severities が空である（strong・mild・normal から 1 つ以上）")
+        unknown = [s for s in value if s not in SEVERITIES]
+        if unknown:
+            raise ValueError(
+                f"data.severities に未知の値がある: {', '.join(map(repr, unknown))}"
+                f"（有効値: {', '.join(SEVERITIES)}）"
+            )
+        if len(set(value)) != len(value):
+            raise ValueError("data.severities に重複がある")
+        # 記載順の違いで config.yaml の記録が揺れないよう，定義順にそろえる．
+        return tuple(s for s in SEVERITIES if s in value)
+
     @property
     def images_dir(self) -> Path:
         """画像ディレクトリ（`<root>/images`）."""
diff --git a/tests/cli/test_dataset.py b/tests/cli/test_dataset.py
new file mode 100644
index 0000000..891ed3e
--- /dev/null
+++ b/tests/cli/test_dataset.py
@@ -0,0 +1,284 @@
+"""tias-dataset CLI のテスト.
+
+仕様: SPEC_01「CLI」「実験の出力」「データセット集計の出力」「回収ホワイトリスト」．
+
+- build-manifest は既存の manifest があれば --overwrite 無しで止まり，ありなら上書きする
+- survey は runs/<実験ID>/ に dataset_summary.json・config.yaml・log.txt・figures/*.png を書く
+- 実験 ID は `YYYYmmdd-HHMMSS_survey_<git短縮ハッシュ>`（TIAS_GIT_COMMIT が無ければ nogit）
+- 出力（ファイル・ログ・標準出力）に患者 ID・ファイル名を出さない
+- 書き出すファイルはすべて回収ホワイトリストの対象（手元へ持ち帰れる集計値だけ）
+
+データは scripts/make_synthetic_dataset.py で tmp_path に作る合成データ（臨床データは使わない）．
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import json
+import logging
+import re
+import sys
+from datetime import datetime
+from pathlib import Path
+from types import ModuleType
+
+import pytest
+import yaml
+from PIL import Image
+
+import tias_judge_model.cli.dataset as cli
+from tias_judge_model.data.manifest import read_manifest
+from tias_judge_model.remote.whitelist import is_pull_allowed
+
+SCRIPT_PATH = Path(__file__).resolve().parents[2] / "scripts" / "make_synthetic_dataset.py"
+SECRET = "SECRETPT"
+RUN_ID_RE = re.compile(r"^\d{8}-\d{6}_survey_(?P<git>.+)$")
+
+
+@pytest.fixture(scope="module")
+def script() -> ModuleType:
+    spec = importlib.util.spec_from_file_location("make_synthetic_dataset_cli", SCRIPT_PATH)
+    assert spec is not None and spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+@pytest.fixture
+def workspace(tmp_path: Path, monkeypatch: pytest.MonkeyPatch, script: ModuleType) -> Path:
+    """合成データと設定 YAML を作り，作業ディレクトリに移る.
+
+    ファイル名（＝患者 ID）には目印の文字列を含める．
+
+    Returns:
+        設定 YAML のパス．
+    """
+    data_root = tmp_path / "dataset"
+    script.generate(data_root, per_dir=6, seed=0)
+    (data_root / "manifest.csv").unlink()
+    # ファイル名（= 患者 ID）に目印を入れ，出力に紛れ込んでいないか検索できるようにする
+    for n, png in enumerate(sorted((data_root / "images").rglob("*.png"))):
+        png.rename(png.with_name(f"{SECRET}{n:04d}.png"))
+    # 読めない画像を 1 枚混ぜる（集計は止めずに件数として数える）
+    (data_root / "images" / "red_mild" / f"{SECRET}BROKEN.png").write_bytes(b"not a png")
+
+    config = tmp_path / "survey.yaml"
+    config.write_text(
+        f"data:\n  root: {data_root.as_posix()}\n"
+        "split:\n  seed: 42\n  val_ratio: 0.15\n  test_ratio: 0.15\n  n_folds: 5\n",
+        encoding="utf-8",
+    )
+    work = tmp_path / "work"
+    work.mkdir()
+    monkeypatch.chdir(work)
+    for var in ("TIAS_DATA_ROOT", "TIAS_GIT_COMMIT"):
+        monkeypatch.delenv(var, raising=False)
+    return config
+
+
+def _manifest_path(config: Path) -> Path:
+    return config.parent / "dataset" / "manifest.csv"
+
+
+def _run_dirs(root: Path) -> list[Path]:
+    runs = root / "runs"
+    return sorted(p for p in runs.iterdir()) if runs.exists() else []
+
+
+# ---------------------------------------------------------------------------
+# build-manifest
+# ---------------------------------------------------------------------------
+
+
+class TestBuildManifest:
+    def test_writes_manifest(self, workspace: Path) -> None:
+        assert cli.main(["build-manifest", "--config", str(workspace)]) == 0
+        records = read_manifest(_manifest_path(workspace))
+        assert len(records) == 9 * 6 + 1
+
+    def test_existing_manifest_requires_overwrite(self, workspace: Path) -> None:
+        manifest = _manifest_path(workspace)
+        assert cli.main(["build-manifest", "--config", str(workspace)]) == 0
+        original = manifest.read_bytes()
+        # 画像を 1 枚足してから再実行 → --overwrite 無しでは止まり，manifest は変わらない
+        extra = manifest.parent / "images" / "pale_mild" / f"{SECRET}EXTRA.png"
+        Image.new("RGB", (8, 8), (200, 180, 180)).save(extra)
+        assert cli.main(["build-manifest", "--config", str(workspace)]) != 0
+        assert manifest.read_bytes() == original
+        # --overwrite で上書きされる
+        assert cli.main(["build-manifest", "--config", str(workspace), "--overwrite"]) == 0
+        assert len(read_manifest(manifest)) == 9 * 6 + 2
+
+
+# ---------------------------------------------------------------------------
+# survey
+# ---------------------------------------------------------------------------
+
+
+def _survey(
+    workspace: Path,
+    caplog: pytest.LogCaptureFixture,
+    capsys: pytest.CaptureFixture[str],
+) -> tuple[int, Path | None, str]:
+    """manifest を作ってから survey を実行し，(終了コード, 実験ディレクトリ, 出力全体) を返す."""
+    # log.txt に INFO が書かれるよう，ルートロガーの水準を INFO にする
+    caplog.set_level(logging.INFO)
+    assert cli.main(["build-manifest", "--config", str(workspace)]) == 0
+    rc = cli.main(["survey", "--config", str(workspace)])
+    captured = capsys.readouterr()
+    dirs = _run_dirs(Path.cwd())
+    run_dir = dirs[0] if len(dirs) == 1 else None
+    return rc, run_dir, captured.out + captured.err + caplog.text
+
+
+class TestSurvey:
+    def test_writes_summary_files_under_run_id(
+        self,
+        workspace: Path,
+        caplog: pytest.LogCaptureFixture,
+        capsys: pytest.CaptureFixture[str],
+    ) -> None:
+        caplog.set_level(logging.INFO)
+        assert cli.main(["build-manifest", "--config", str(workspace)]) == 0
+        capsys.readouterr()
+        assert cli.main(["survey", "--config", str(workspace)]) == 0
+        out = capsys.readouterr().out
+
+        dirs = _run_dirs(Path.cwd())
+        assert len(dirs) == 1
+        run_dir = dirs[0]
+        match = RUN_ID_RE.match(run_dir.name)
+        assert match is not None, run_dir.name
+        assert match["git"] == "nogit"  # TIAS_GIT_COMMIT が無い
+        # 実験 ID を標準出力へ出す（tias-remote pull に使う）
+        assert out.strip().splitlines()[-1] == run_dir.name
+
+        assert (run_dir / "dataset_summary.json").is_file()
+        assert (run_dir / "config.yaml").is_file()
+        assert (run_dir / "log.txt").is_file()
+        assert (run_dir / "log.txt").read_text(encoding="utf-8").strip()
+        figures = sorted((run_dir / "figures").glob("*.png"))
+        assert figures
+        for fig in figures:
+            with Image.open(fig) as img:
+                assert img.format == "PNG"
+
+        summary = json.loads((run_dir / "dataset_summary.json").read_text(encoding="utf-8"))
+        assert summary["counts"]["total"]["images"] == 9 * 6 + 1
+        assert summary["loading"]["unreadable"] == 1
+        assert len(summary["delta_e"]["mild_comparison"]) == 4
+
+    def test_all_outputs_are_pull_allowed(
+        self,
+        workspace: Path,
+        caplog: pytest.LogCaptureFixture,
+        capsys: pytest.CaptureFixture[str],
+    ) -> None:
+        rc, run_dir, _ = _survey(workspace, caplog, capsys)
+        assert rc == 0 and run_dir is not None
+        files = [p.relative_to(run_dir).as_posix() for p in run_dir.rglob("*") if p.is_file()]
+        assert "dataset_summary.json" in files
+        for name in files:
+            assert is_pull_allowed(name, with_checkpoints=False), name
+
+    def test_no_patient_id_or_filename_in_outputs(
+        self,
+        workspace: Path,
+        caplog: pytest.LogCaptureFixture,
+        capsys: pytest.CaptureFixture[str],
+    ) -> None:
+        rc, run_dir, console = _survey(workspace, caplog, capsys)
+        assert rc == 0 and run_dir is not None
+        assert SECRET not in console
+        for path in run_dir.rglob("*"):
+            if path.is_file() and path.suffix != ".png":
+                text = path.read_text(encoding="utf-8")
+                assert SECRET not in text, path.name
+                assert ".png" not in text, path.name
+            assert SECRET not in path.name
+
+    def test_git_commit_from_environment(
+        self,
+        workspace: Path,
+        monkeypatch: pytest.MonkeyPatch,
+        caplog: pytest.LogCaptureFixture,
+        capsys: pytest.CaptureFixture[str],
+    ) -> None:
+        monkeypatch.setenv("TIAS_GIT_COMMIT", "abc1234-dirty")
+        rc, run_dir, _ = _survey(workspace, caplog, capsys)
+        assert rc == 0 and run_dir is not None
+        match = RUN_ID_RE.match(run_dir.name)
+        assert match is not None and match["git"] == "abc1234-dirty"
+        # config.yaml に git のハッシュと seed が記録される
+        document = yaml.safe_load((run_dir / "config.yaml").read_text(encoding="utf-8"))
+        text = json.dumps(document, ensure_ascii=False)
+        assert "abc1234-dirty" in text
+        assert document["config"]["split"]["seed"] == 42
+
+    @pytest.mark.parametrize("value", ["../evil", "a b", "x;rm -rf ~", "abc/def", "-dirty"])
+    def test_invalid_git_commit_is_rejected(
+        self,
+        workspace: Path,
+        monkeypatch: pytest.MonkeyPatch,
+        caplog: pytest.LogCaptureFixture,
+        capsys: pytest.CaptureFixture[str],
+        value: str,
+    ) -> None:
+        monkeypatch.setenv("TIAS_GIT_COMMIT", value)
+        rc, _run_dir, _ = _survey(workspace, caplog, capsys)
+        assert rc != 0
+        assert _run_dirs(Path.cwd()) == []
+        assert not (Path.cwd().parent / "evil").exists()
+
+    def test_severities_setting_is_recorded(
+        self,
+        workspace: Path,
+        caplog: pytest.LogCaptureFixture,
+        capsys: pytest.CaptureFixture[str],
+    ) -> None:
+        workspace.write_text(
+            workspace.read_text(encoding="utf-8").replace(
+                "data:\n", "data:\n  severities: [strong, normal]\n", 1
+            ),
+            encoding="utf-8",
+        )
+        rc, run_dir, _ = _survey(workspace, caplog, capsys)
+        assert rc == 0 and run_dir is not None
+        summary = json.loads((run_dir / "dataset_summary.json").read_text(encoding="utf-8"))
+        assert summary["configured_severities"] == ["strong", "normal"]
+        # 集計は設定に関わらず全データで行い，条件ごとの件数を並べる
+        assert summary["counts"]["total"]["images"] == 9 * 6 + 1
+        conditions = summary["counts"]["conditions"]
+        assert conditions["with_mild"]["images"] == 9 * 6 + 1
+        assert conditions["without_mild"]["images"] == 5 * 6
+
+    def test_missing_manifest_is_error(
+        self, workspace: Path, caplog: pytest.LogCaptureFixture
+    ) -> None:
+        caplog.set_level(logging.INFO)
+        assert cli.main(["survey", "--config", str(workspace)]) != 0
+
+
+# ---------------------------------------------------------------------------
+# 実験 ID
+# ---------------------------------------------------------------------------
+
+
+class TestRunId:
+    def test_format(self) -> None:
+        now = datetime(2026, 9, 27, 8, 5, 3)
+        assert cli.make_run_id(now, "survey", "abc1234") == "20260927-080503_survey_abc1234"
+
+    @pytest.mark.parametrize("environ", [{}, {"TIAS_GIT_COMMIT": ""}, {"OTHER": "x"}])
+    def test_nogit_when_absent(self, environ: dict[str, str]) -> None:
+        assert cli.resolve_git_commit(environ) == "nogit"
+
+    @pytest.mark.parametrize("value", ["abc1234", "abc1234-dirty", "0123456789abcdef"])
+    def test_valid_git_commit(self, value: str) -> None:
+        assert cli.resolve_git_commit({"TIAS_GIT_COMMIT": value}) == value
+
+    @pytest.mark.parametrize("value", ["../x", "a b", "a/b", "$(id)", "-x"])
+    def test_invalid_git_commit(self, value: str) -> None:
+        with pytest.raises(ValueError):
+            cli.resolve_git_commit({"TIAS_GIT_COMMIT": value})
diff --git a/tests/cli/test_remote.py b/tests/cli/test_remote.py
index f911a62..f3b434d 100644
--- a/tests/cli/test_remote.py
+++ b/tests/cli/test_remote.py
@@ -5,12 +5,16 @@
 - 手元のホスト名がサーバ名と一致したら止まる（`TIAS_REMOTE_ALLOW_SELF=1` で無効化）
 - pull は回収ホワイトリストに一致するファイルだけを持ち帰り，回収しなかったファイルの名前を
   出さない．受け取った tar に不正なメンバーがあれば何も展開しない
+- run はジョブに TIAS_GIT_COMMIT（未コミットの変更があれば -dirty 付き）を渡す．手元の git は
+  subprocess.run をモックする（実プロセスは起動しない）
+- run --cpu は GPU を観測・選択せず，CUDA_VISIBLE_DEVICES を空文字で渡す
 """
 
 from __future__ import annotations
 
 import io
 import logging
+import subprocess
 import tarfile
 import threading
 from collections.abc import Callable
@@ -104,8 +108,49 @@
     return lambda argv: cli._SshResult(rc, b"", stderr)
 
 
+class FakeGit:
+    """手元の git（`subprocess.run(["git", ...])`）の代わり．git 以外のコマンドは拒否する.
+
+    Attributes:
+        head: `git rev-parse --short HEAD` の出力．None なら失敗（リポジトリでない等）．
+        status: `git status --porcelain` の出力．None なら失敗．
+        missing: True なら git が無い（FileNotFoundError）．
+    """
+
+    def __init__(self) -> None:
+        self.head: str | None = "abc1234\n"
+        self.status: str | None = ""
+        self.missing = False
+        self.calls: list[list[str]] = []
+
+    def __call__(self, argv: list[str], *args: object, **kwargs: object):
+        argv = list(argv)
+        if not argv or argv[0] != "git":
+            raise AssertionError("テストが git 以外の実プロセスを起動しようとした")
+        self.calls.append(argv)
+        if self.missing:
+            raise FileNotFoundError("git")
+        if "rev-parse" in argv:
+            out = self.head
+        elif "status" in argv:
+            out = self.status
+        else:
+            raise AssertionError(f"想定外の git コマンド: {argv}")
+        if out is None:
+            return subprocess.CompletedProcess(argv, 128, "", "fatal: not a git repository")
+        return subprocess.CompletedProcess(argv, 0, out, "")
+
+
 @pytest.fixture
-def project(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Path:
+def fake_git(monkeypatch: pytest.MonkeyPatch) -> FakeGit:
+    """`run` が手元で求める TIAS_GIT_COMMIT 用の git をモックする（実プロセスは起動しない）."""
+    fake = FakeGit()
+    monkeypatch.setattr(cli.subprocess, "run", fake)
+    return fake
+
+
+@pytest.fixture
+def project(tmp_path: Path, monkeypatch: pytest.MonkeyPatch, fake_git: FakeGit) -> Path:
     """手元のプロジェクトルートを模したディレクトリ（ssh は一切起動させない）."""
     root = tmp_path / "proj"
     (root / "src" / "tias_judge_model").mkdir(parents=True)
@@ -455,3 +500,261 @@
         assert "runs/x" not in out
         assert ".claude" not in out
         assert fake.calls == []
+
+
+# ---------------------------------------------------------------------------
+# run: TIAS_GIT_COMMIT（SPEC_03「run」・SPEC_01「実験の出力」）
+# ---------------------------------------------------------------------------
+
+
+def _spy_job_script(monkeypatch: pytest.MonkeyPatch) -> list[dict]:
+    """`build_job_script` に渡された引数（env・gpu_index・server_name）を記録する."""
+    captured: list[dict] = []
+    original = cli.build_job_script
+
+    def spy(*args, **kwargs):
+        captured.append(kwargs)
+        return original(*args, **kwargs)
+
+    monkeypatch.setattr(cli, "build_job_script", spy)
+    return captured
+
+
+def _free_everywhere(monkeypatch: pytest.MonkeyPatch) -> FakeSsh:
+    fake = FakeSsh(
+        {
+            NEWTON_ADDR: _ok(_probe_stdout([(0, 5, 0)])),
+            ARCHIMEDES_ADDR: _ok(_probe_stdout([(0, 5, 0)])),
+        }
+    )
+    monkeypatch.setattr(cli, "_run_ssh", fake)
+    return fake
+
+
+class TestRunGitCommit:
+    def test_clean_tree_passes_short_hash(
+        self,
+        project: Path,
+        monkeypatch: pytest.MonkeyPatch,
+        fake_git: FakeGit,
+        capsys: pytest.CaptureFixture[str],
+    ) -> None:
+        _free_everywhere(monkeypatch)
+        captured = _spy_job_script(monkeypatch)
+        assert cli.main(["run", "--name", "exp1", "--dry-run", "--", "python"]) == 0
+        assert captured[0]["env"]["TIAS_GIT_COMMIT"] == "abc1234"
+        # ジョブのスクリプトに実際に export される
+        assert "export TIAS_GIT_COMMIT=abc1234" in capsys.readouterr().out
+        assert fake_git.calls
+
+    def test_dirty_tree_appends_suffix(
+        self,
+        project: Path,
+        monkeypatch: pytest.MonkeyPatch,
+        fake_git: FakeGit,
+        capsys: pytest.CaptureFixture[str],
+    ) -> None:
+        fake_git.status = " M src/tias_judge_model/schema.py\n"
+        _free_everywhere(monkeypatch)
+        captured = _spy_job_script(monkeypatch)
+        assert cli.main(["run", "--name", "exp1", "--dry-run", "--", "python"]) == 0
+        assert captured[0]["env"]["TIAS_GIT_COMMIT"] == "abc1234-dirty"
+        assert "export TIAS_GIT_COMMIT=abc1234-dirty" in capsys.readouterr().out
+
+    @pytest.mark.parametrize("failure", ["missing", "not_repo", "status_fails"])
+    def test_git_unavailable_does_not_set_variable(
+        self,
+        project: Path,
+        monkeypatch: pytest.MonkeyPatch,
+        fake_git: FakeGit,
+        capsys: pytest.CaptureFixture[str],
+        failure: str,
+    ) -> None:
+        if failure == "missing":
+            fake_git.missing = True
+        elif failure == "not_repo":
+            fake_git.head = None
+        else:
+            fake_git.status = None
+        _free_everywhere(monkeypatch)
+        captured = _spy_job_script(monkeypatch)
+        # git が使えなくてもジョブは起動できる（ジョブ側は nogit になる）
+        assert cli.main(["run", "--name", "exp1", "--dry-run", "--", "python"]) == 0
+        assert "TIAS_GIT_COMMIT" not in captured[0]["env"]
+        assert "TIAS_GIT_COMMIT" not in capsys.readouterr().out
+
+    @pytest.mark.parametrize("git_ok", [True, False])
+    def test_env_option_cannot_override_git_commit(
+        self, project: Path, monkeypatch: pytest.MonkeyPatch, fake_git: FakeGit, git_ok: bool
+    ) -> None:
+        fake_git.missing = not git_ok
+        fake = _free_everywhere(monkeypatch)
+        args = ["run", "--name", "exp1", "--env", "TIAS_GIT_COMMIT=fake", "--", "python"]
+        assert cli.main(args) != 0
+        # probe の 2 回だけで，起動のための ssh は呼ばない
+        assert len(fake.calls) == 2
+
+
+# ---------------------------------------------------------------------------
+# run --cpu（SPEC_03「run」）
+# ---------------------------------------------------------------------------
+
+
+def _probe_stdout_instant() -> bytes:
+    """観測なし（瞬間値のみ）の probe の出力．GPU は使用中."""
+    lines = [
+        PROBE_SESSIONS_MARKER,
+        PROBE_GPUS_MARKER,
+        "0, GPU-0, NVIDIA RTX A6000, 20000, 49140, 95",
+        f"{PROBE_GPU_RC_PREFIX}0",
+        PROBE_APPS_MARKER,
+        "GPU-0, 4321, 20000",
+        f"{PROBE_APPS_RC_PREFIX}0",
+        PROBE_OWNERS_MARKER,
+        PROBE_END_MARKER,
+    ]
+    return ("\n".join(lines) + "\n").encode()
+
+
+def _forbid_gpu_selection(monkeypatch: pytest.MonkeyPatch) -> None:
+    def forbidden(*args: object, **kwargs: object) -> None:
+        raise AssertionError("--cpu で GPU を選ぼうとした")
+
+    monkeypatch.setattr(cli, "select_gpu", forbidden)
+
+
+def _write_remote_config(project: Path, *, newton_data_ready: bool) -> None:
+    text = CONFIG_YAML
+    if not newton_data_ready:
+        text = text.replace("data_ready: true", "data_ready: false", 1)
+    (project / "configs" / "remote.yaml").write_text(text, encoding="utf-8")
+
+
+class TestRunCpu:
+    def _setup(
+        self,
+        monkeypatch: pytest.MonkeyPatch,
+        *,
+        newton_ok: bool = True,
+        archimedes_ok: bool = True,
+    ) -> tuple[FakeSsh, list[dict]]:
+        # GPU はすべて使用中にしておく（--cpu では GPU の状態に関わらず起動できること）
+        fake = FakeSsh(
+            {
+                NEWTON_ADDR: _ok(_probe_stdout_instant()) if newton_ok else _fail(),
+                ARCHIMEDES_ADDR: _ok(_probe_stdout_instant()) if archimedes_ok else _fail(),
+            }
+        )
+        monkeypatch.setattr(cli, "_run_ssh", fake)
+        _forbid_gpu_selection(monkeypatch)
+        return fake, _spy_job_script(monkeypatch)
+
+    def test_does_not_observe_or_select_gpu(
+        self, project: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        fake, captured = self._setup(monkeypatch)
+        args = ["run", "--name", "survey", "--cpu", "--dry-run", "--", "tias-dataset", "survey"]
+        assert cli.main(args) == 0
+        assert fake.calls
+        for argv in fake.calls:
+            remote_command = argv[-1]
+            assert PROBE_SAMPLES_MARKER not in remote_command
+            assert "-lms" not in remote_command
+            assert "pmon" not in remote_command
+        assert captured[0]["gpu_index"] is None
+
+    def test_cuda_visible_devices_is_empty_string(
+        self, project: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        _fake, captured = self._setup(monkeypatch)
+        assert cli.main(["run", "--name", "s", "--cpu", "--dry-run", "--", "x"]) == 0
+        env = captured[0]["env"]
+        assert "CUDA_VISIBLE_DEVICES" in env
+        assert env["CUDA_VISIBLE_DEVICES"] == ""
+        assert env["TIAS_GIT_COMMIT"] == "abc1234"
+
+    def test_log_header_says_no_gpu(
+        self, project: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+    ) -> None:
+        self._setup(monkeypatch)
+        assert cli.main(["run", "--name", "s", "--cpu", "--dry-run", "--", "x"]) == 0
+        assert "gpu=なし（CPU）" in capsys.readouterr().out
+
+    def test_without_server_uses_highest_priority_reachable(
+        self, project: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        _fake, captured = self._setup(monkeypatch)
+        assert cli.main(["run", "--name", "s", "--cpu", "--dry-run", "--", "x"]) == 0
+        assert captured[0]["server_name"] == "Newton"
+
+    def test_unreachable_server_is_skipped(
+        self, project: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        _fake, captured = self._setup(monkeypatch, newton_ok=False)
+        assert cli.main(["run", "--name", "s", "--cpu", "--dry-run", "--", "x"]) == 0
+        assert captured[0]["server_name"] == "Archimedes"
+
+    def test_all_unreachable_is_error(self, project: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+        _fake, captured = self._setup(monkeypatch, newton_ok=False, archimedes_ok=False)
+        assert cli.main(["run", "--name", "s", "--cpu", "--dry-run", "--", "x"]) != 0
+        assert captured == []
+
+    def test_explicit_server(self, project: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+        _fake, captured = self._setup(monkeypatch)
+        args = ["run", "--name", "s", "--cpu", "--server", "Archimedes", "--dry-run", "--", "x"]
+        assert cli.main(args) == 0
+        assert captured[0]["server_name"] == "Archimedes"
+
+    def test_explicit_unreachable_server_is_error(
+        self, project: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        _fake, captured = self._setup(monkeypatch, archimedes_ok=False)
+        args = ["run", "--name", "s", "--cpu", "--server", "Archimedes", "--dry-run", "--", "x"]
+        assert cli.main(args) != 0
+        assert captured == []
+
+    def test_data_not_ready_server_is_skipped_without_no_data(
+        self, project: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        _write_remote_config(project, newton_data_ready=False)
+        _fake, captured = self._setup(monkeypatch)
+        assert cli.main(["run", "--name", "s", "--cpu", "--dry-run", "--", "x"]) == 0
+        assert captured[0]["server_name"] == "Archimedes"
+
+    def test_no_data_includes_not_ready_server(
+        self, project: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        _write_remote_config(project, newton_data_ready=False)
+        _fake, captured = self._setup(monkeypatch)
+        args = ["run", "--name", "s", "--cpu", "--no-data", "--dry-run", "--", "x"]
+        assert cli.main(args) == 0
+        assert captured[0]["server_name"] == "Newton"
+
+    @pytest.mark.parametrize(
+        "extra",
+        [
+            ["--gpu", "0", "--server", "Newton"],
+            ["--gpu", "0"],
+            ["--force"],
+            ["--observe", "0"],
+            ["--observe", "10"],
+        ],
+    )
+    def test_gpu_options_are_rejected_before_ssh(
+        self, project: Path, monkeypatch: pytest.MonkeyPatch, extra: list[str]
+    ) -> None:
+        fake = FakeSsh({})
+        monkeypatch.setattr(cli, "_run_ssh", fake)
+        assert cli.main(["run", "--name", "s", "--cpu", *extra, "--dry-run", "--", "x"]) != 0
+        assert fake.calls == []
+
+    def test_launch_on_selected_server(
+        self, project: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        # --no-push で起動まで進める（起動の ssh もモック）
+        fake, captured = self._setup(monkeypatch)
+        assert cli.main(["run", "--name", "s", "--cpu", "--no-push", "--", "x"]) == 0
+        launch = fake.calls[-1]
+        assert f"hasegawa@{NEWTON_ADDR}" in launch
+        assert "tmux" in launch[-1]
+        assert captured[0]["env"]["CUDA_VISIBLE_DEVICES"] == ""
diff --git a/tests/data/test_color.py b/tests/data/test_color.py
new file mode 100644
index 0000000..5f5aa3a
--- /dev/null
+++ b/tests/data/test_color.py
@@ -0,0 +1,112 @@
+"""舌領域の色（Lab）と色差のテスト（SPEC_01「データセット集計の出力」）.
+
+- Lab の計算: sRGB（ガンマ補正を外して線形化）→ XYZ（D65）→ CIE L*a*b*（D65 白色点）
+- 背景の定義: RGB がすべて 0 の画素を背景とし，それ以外を舌領域とする
+- 色差: CIE76（L*a*b* のユークリッド距離）
+
+期待値は sRGB の標準的な参照値（D65・2° 視野．例: 赤 (255,0,0) → L*≈53.24, a*≈80.09,
+b*≈67.20）．
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+from tias_judge_model.data.color import delta_e_cie76, mean_tongue_lab, rgb8_to_lab, tongue_mask
+
+# 参照値の丸めの違い（公開されている表どうしで小数第 2 位程度ずれる）を許す
+TOL = 0.05
+
+
+def _lab(rgb: tuple[int, int, int]) -> np.ndarray:
+    return rgb8_to_lab(np.array(rgb, dtype=np.uint8))
+
+
+class TestRgbToLab:
+    @pytest.mark.parametrize(
+        ("rgb", "expected"),
+        [
+            ((255, 255, 255), (100.0, 0.0, 0.0)),
+            ((0, 0, 0), (0.0, 0.0, 0.0)),
+            ((255, 0, 0), (53.24, 80.09, 67.20)),
+            ((0, 255, 0), (87.73, -86.18, 83.18)),
+            ((0, 0, 255), (32.30, 79.19, -107.86)),
+            ((128, 128, 128), (53.59, 0.0, 0.0)),
+            ((119, 119, 119), (50.03, 0.0, 0.0)),
+        ],
+    )
+    def test_known_colors(
+        self, rgb: tuple[int, int, int], expected: tuple[float, float, float]
+    ) -> None:
+        assert _lab(rgb) == pytest.approx(expected, abs=TOL)
+
+    def test_gray_has_zero_chroma(self) -> None:
+        # D65 白色点で正規化しているため，無彩色は a* = b* = 0 になる
+        for v in (1, 50, 200, 254):
+            lab = _lab((v, v, v))
+            assert lab[1] == pytest.approx(0.0, abs=1e-6)
+            assert lab[2] == pytest.approx(0.0, abs=1e-6)
+
+    def test_lightness_is_monotonic_in_gray(self) -> None:
+        values = [_lab((v, v, v))[0] for v in range(0, 256, 5)]
+        assert values == sorted(values)
+
+    def test_vectorized_shape(self) -> None:
+        pixels = np.zeros((4, 5, 3), dtype=np.uint8)
+        pixels[..., 0] = 255
+        lab = rgb8_to_lab(pixels)
+        assert lab.shape == (4, 5, 3)
+        assert lab[2, 3] == pytest.approx((53.24, 80.09, 67.20), abs=TOL)
+
+
+class TestTongueMask:
+    def test_only_all_zero_pixels_are_background(self) -> None:
+        pixels = np.array(
+            [[[0, 0, 0], [0, 0, 1]], [[1, 0, 0], [0, 1, 0]]],
+            dtype=np.uint8,
+        )
+        mask = tongue_mask(pixels)
+        assert mask.shape == (2, 2)
+        assert mask.tolist() == [[False, True], [True, True]]
+
+
+class TestMeanTongueLab:
+    def test_background_is_excluded(self) -> None:
+        # 半分が背景（黒），半分が白 → 舌領域だけの平均なので白の Lab になる（黒と混ぜない）
+        pixels = np.zeros((10, 10, 3), dtype=np.uint8)
+        pixels[:, :5] = 255
+        assert mean_tongue_lab(pixels) == pytest.approx((100.0, 0.0, 0.0), abs=TOL)
+
+    def test_mean_over_tongue_pixels(self) -> None:
+        # 舌領域が白と赤の半々 → 各画素の Lab の平均
+        pixels = np.zeros((6, 6, 3), dtype=np.uint8)
+        pixels[:3, :3] = (255, 255, 255)
+        pixels[3:, :3] = (255, 0, 0)
+        expected = (_lab((255, 255, 255)) + _lab((255, 0, 0))) / 2
+        assert mean_tongue_lab(pixels) == pytest.approx(expected, abs=1e-6)
+
+    def test_no_tongue_pixels_does_not_crash(self) -> None:
+        pixels = np.zeros((4, 4, 3), dtype=np.uint8)
+        assert mean_tongue_lab(pixels) is None
+
+
+class TestDeltaE:
+    def test_euclidean_distance(self) -> None:
+        assert delta_e_cie76(np.array([50.0, 0.0, 0.0]), np.array([53.0, 4.0, 0.0])) == (
+            pytest.approx(5.0)
+        )
+        assert delta_e_cie76(np.array([10.0, 20.0, 30.0]), np.array([10.0, 20.0, 30.0])) == 0.0
+
+    def test_symmetric(self) -> None:
+        a, b = _lab((255, 0, 0)), _lab((0, 0, 255))
+        assert delta_e_cie76(a, b) == pytest.approx(delta_e_cie76(b, a))
+
+    def test_white_vs_black_is_100(self) -> None:
+        assert delta_e_cie76(_lab((255, 255, 255)), _lab((0, 0, 0))) == pytest.approx(100.0)
+
+    def test_red_vs_white(self) -> None:
+        # sqrt((100-53.24)^2 + 80.09^2 + 67.20^2) ≈ 114.56
+        assert delta_e_cie76(_lab((255, 0, 0)), _lab((255, 255, 255))) == pytest.approx(
+            114.56, abs=0.05
+        )
diff --git a/tests/data/test_split.py b/tests/data/test_split.py
index caa7675..eb6c9be 100644
--- a/tests/data/test_split.py
+++ b/tests/data/test_split.py
@@ -9,16 +9,25 @@
 
 import pytest
 
-from tias_judge_model.data.classes import CLASS_SLUGS, VALID_SEVERITIES
+from tias_judge_model.data.classes import (
+    ALL_DIR_NAMES,
+    CLASS_SLUGS,
+    VALID_SEVERITIES,
+    parse_dir_name,
+)
 from tias_judge_model.data.manifest import ManifestRecord
 from tias_judge_model.data.split import (
     Fold,
     SplitResult,
     count_by_class,
     count_by_class_severity,
+    count_by_group,
+    filter_by_severity,
     make_kfold_splits,
+    patient_groups,
     patient_labels,
     select_records,
+    split_records,
     split_train_val_test,
 )
 
@@ -49,6 +58,27 @@
     return records
 
 
+def make_group_records(
+    patients_per_group: dict[str, int], images_per_patient: int = 1, prefix: str = "g"
+) -> list[ManifestRecord]:
+    """層化グループ（`<label>_<severity>`）ごとに指定人数の患者を持つ合成 manifest を作る."""
+    records = []
+    for group, n_patients in patients_per_group.items():
+        label, severity = parse_dir_name(group)
+        for p in range(n_patients):
+            patient_id = f"{prefix}_{group}_{p:04d}"
+            for k in range(images_per_patient):
+                records.append(
+                    ManifestRecord(
+                        image_path=f"{group}/{patient_id}_{k}.png",
+                        patient_id=patient_id,
+                        label=label,
+                        severity=severity,
+                    )
+                )
+    return records
+
+
 def shuffled(records: list[ManifestRecord], seed: int) -> list[ManifestRecord]:
     out = list(records)
     random.Random(seed).shuffle(out)
@@ -156,12 +186,25 @@
 
 
 def test_single_split_sizes_follow_ratios() -> None:
+    # SPEC_02: 層化グループ（クラス × 程度の 9 グループ）ごとに「患者数 × 比率」を四捨五入する．
+    # make_records(20) は light_red_normal が 20 人，他の 8 グループが 10 人ずつ．
     records = make_records(20)
     result = split_train_val_test(records, val_ratio=0.15, test_ratio=0.15, seed=SEED)
-    # 各クラス 20 人 × 0.15 = 3 人
-    assert len(result.val) == 15
-    assert len(result.test) == 15
-    assert len(result.train) == 70
+    # light_red_normal: 20 × 0.15 = 3 人．他の 8 グループ: 10 × 0.15 = 1.5 → 四捨五入で 2 人
+    expected = 3 + 8 * 2
+    assert len(result.val) == expected
+    assert len(result.test) == expected
+    assert len(result.train) == 100 - 2 * expected
+
+
+def test_single_split_rounds_half_up_per_group() -> None:
+    # 2.5 → 3（偶数丸めの 2 ではない）．各グループ 10 人 × 0.25 = 2.5
+    records = make_group_records(dict.fromkeys(ALL_DIR_NAMES, 10))
+    result = split_train_val_test(records, val_ratio=0.25, test_ratio=0.25, seed=SEED)
+    groups = patient_groups(records)
+    for part in (result.val, result.test):
+        counts = Counter(groups[p] for p in part)
+        assert counts == dict.fromkeys(ALL_DIR_NAMES, 3)
 
 
 def test_single_split_to_dict_contains_all_parts() -> None:
@@ -231,7 +274,10 @@
 
 
 def test_kfold_with_uneven_images_per_patient_stays_disjoint() -> None:
-    records = make_records(6, prefix="one") + make_records(6, images_per_patient=4, prefix="many")
+    # 各層化グループの患者数が fold 数（5）以上になる構成（SPEC_02: 満たないグループがあれば停止）．
+    # "one" は 1 患者 1 枚（strong / mild が 5 人ずつ），"many" は 1 患者 4 枚（strong と mild が
+    # 混在し，最も強い strong で層化される）
+    records = make_records(10, prefix="one") + make_records(10, images_per_patient=4, prefix="many")
     for fold in make_kfold_splits(records, n_folds=5, seed=SEED):
         train_recs = select_records(records, fold.train)
         held_recs = select_records(records, fold.held_out)
@@ -314,3 +360,214 @@
     assert counts == {("light_red", "normal"): 2, ("red", "strong"): 2, ("red", "mild"): 1}
     # クラス ID 順に並ぶ
     assert [label for label, _ in counts][0] == "light_red"
+
+
+# --- 層化（クラス × 程度の 9 グループ．SPEC_02「データ分割」） ---
+
+# 実データの 1/5 程度で，グループごとに人数が異なる分布
+UNEVEN_GROUPS = {
+    "pale_strong": 12,
+    "pale_mild": 11,
+    "light_red_normal": 40,
+    "red_strong": 14,
+    "red_mild": 13,
+    "dark_red_strong": 30,
+    "dark_red_mild": 20,
+    "purple_strong": 16,
+    "purple_mild": 15,
+}
+
+
+def _round_half_up(value: float) -> int:
+    return int(value + 0.5)
+
+
+def test_single_split_is_stratified_by_nine_groups() -> None:
+    records = make_group_records(UNEVEN_GROUPS)
+    result = split_train_val_test(records, val_ratio=0.15, test_ratio=0.15, seed=SEED)
+    groups = patient_groups(records)
+
+    for part in (result.train, result.val, result.test):
+        counts = Counter(groups[p] for p in part)
+        assert set(counts) == set(ALL_DIR_NAMES), "各分割に 9 グループすべてが含まれること"
+    # val / test の人数はグループごとに「患者数 × 比率」の四捨五入
+    for part in (result.val, result.test):
+        counts = Counter(groups[p] for p in part)
+        for group, n in UNEVEN_GROUPS.items():
+            assert counts[group] == _round_half_up(n * 0.15), group
+
+
+def test_kfold_is_stratified_by_nine_groups() -> None:
+    records = make_group_records(UNEVEN_GROUPS)
+    groups = patient_groups(records)
+    for fold in make_kfold_splits(records, n_folds=5, seed=SEED):
+        counts = Counter(groups[p] for p in fold.held_out)
+        assert set(counts) == set(ALL_DIR_NAMES), "各 fold の held_out に 9 グループが含まれること"
+        for group, n in UNEVEN_GROUPS.items():
+            assert abs(counts[group] - n / 5) < 1, group
+
+
+def test_single_split_with_nine_groups_is_reproducible() -> None:
+    records = make_group_records(UNEVEN_GROUPS)
+    a = split_train_val_test(records, val_ratio=0.15, test_ratio=0.15, seed=SEED)
+    b = split_train_val_test(shuffled(records, 3), val_ratio=0.15, test_ratio=0.15, seed=SEED)
+    assert a == b
+    assert make_kfold_splits(records, 5, seed=SEED) == make_kfold_splits(
+        shuffled(records, 3), 5, seed=SEED
+    )
+
+
+def test_kfold_stops_when_a_group_has_fewer_patients_than_folds() -> None:
+    per_group = dict.fromkeys(ALL_DIR_NAMES, 10)
+    per_group["red_mild"] = 4
+    with pytest.raises(ValueError):
+        make_kfold_splits(make_group_records(per_group), n_folds=5, seed=SEED)
+    # fold 数以上ならちょうど通る
+    per_group["red_mild"] = 5
+    assert len(make_kfold_splits(make_group_records(per_group), n_folds=5, seed=SEED)) == 5
+
+
+def test_single_split_stops_when_a_group_leaves_no_train_patient() -> None:
+    per_group = dict.fromkeys(ALL_DIR_NAMES, 10)
+    per_group["purple_mild"] = 2  # val 1・test 1（2 × 0.3 = 0.6 → 1）で train が 0 人
+    with pytest.raises(ValueError):
+        split_train_val_test(
+            make_group_records(per_group), val_ratio=0.3, test_ratio=0.3, seed=SEED
+        )
+
+
+def test_patient_with_multiple_severities_uses_strongest() -> None:
+    records = [
+        ManifestRecord("red_mild/a_0.png", "a", "red", "mild"),
+        ManifestRecord("red_strong/a_1.png", "a", "red", "strong"),
+        ManifestRecord("pale_mild/b_0.png", "b", "pale", "mild"),
+        ManifestRecord("light_red_normal/c_0.png", "c", "light_red", "normal"),
+    ]
+    assert patient_groups(records) == {
+        "a": "red_strong",
+        "b": "pale_mild",
+        "c": "light_red_normal",
+    }
+    # 行の順序に依存しない
+    assert patient_groups(list(reversed(records)))["a"] == "red_strong"
+
+
+def test_kfold_stratifies_mixed_patients_by_strongest_severity() -> None:
+    # red_mild だけの患者は 0 人で，mild と strong の両方を持つ患者が 3 人いる．
+    # 最も強い strong で層化されれば red_mild グループは存在せず 5-fold が成り立つ
+    # （mild で層化されると 3 人 < 5 fold で停止する）
+    per_group = dict.fromkeys(ALL_DIR_NAMES, 10)
+    del per_group["red_mild"]
+    records = make_group_records(per_group)
+    for i in range(3):
+        pid = f"mixed_{i}"
+        records.append(ManifestRecord(f"red_mild/{pid}_0.png", pid, "red", "mild"))
+        records.append(ManifestRecord(f"red_strong/{pid}_1.png", pid, "red", "strong"))
+    folds = make_kfold_splits(records, n_folds=5, seed=SEED)
+    held = [p for f in folds for p in f.held_out]
+    assert {f"mixed_{i}" for i in range(3)} <= set(held)
+    # 単一分割でも止まらず，1 患者の画像は同じ分割に入る
+    result = split_train_val_test(records, val_ratio=0.15, test_ratio=0.15, seed=SEED)
+    parts = [set(result.train), set(result.val), set(result.test)]
+    for i in range(3):
+        assert sum(f"mixed_{i}" in part for part in parts) == 1
+
+
+# --- 分割後の程度による除外（SPEC_02「程度（ややあり）の扱い」） ---
+
+WITHOUT_MILD = ("strong", "normal")
+
+
+def _mixed_records() -> list[ManifestRecord]:
+    # グループ別の 1 患者 1 枚の患者に加え，1 患者に strong と mild が混在する患者を含める
+    records = make_group_records(UNEVEN_GROUPS)
+    for i in range(6):
+        pid = f"mixed_{i}"
+        label = ("pale", "red", "dark_red", "purple")[i % 4]
+        records.append(ManifestRecord(f"{label}_strong/{pid}_0.png", pid, label, "strong"))
+        records.append(ManifestRecord(f"{label}_mild/{pid}_1.png", pid, label, "mild"))
+    return records
+
+
+def _assert_exclusion_is_subset(
+    records: list[ManifestRecord], split: SplitResult | Fold, part_names: list[str]
+) -> None:
+    everything = split_records(records, split)
+    with_mild = split_records(records, split, ("strong", "mild", "normal"))
+    without_mild = split_records(records, split, WITHOUT_MILD)
+    assert list(everything) == part_names
+    assert list(without_mild) == part_names
+    # 全程度を指定したときは除外しないときと同じ
+    assert with_mild == everything
+    for name in part_names:
+        kept, full = without_mild[name], everything[name]
+        # 部分集合であり，除かれたのは mild の画像だけ，残ったのは mild 以外のすべて
+        assert set(kept) <= set(full), name
+        removed = set(full) - set(kept)
+        assert all(r.severity == "mild" for r in removed), name
+        assert set(kept) == {r for r in full if r.severity != "mild"}, name
+
+
+def test_single_split_exclusion_is_subset_of_full_split() -> None:
+    records = _mixed_records()
+    split = split_train_val_test(records, val_ratio=0.15, test_ratio=0.15, seed=SEED)
+    _assert_exclusion_is_subset(records, split, ["train", "val", "test"])
+    # 全画像がいずれか 1 つの分割に入る
+    everything = split_records(records, split)
+    assert sum(len(v) for v in everything.values()) == len(records)
+
+
+def test_kfold_exclusion_is_subset_of_full_split() -> None:
+    records = _mixed_records()
+    for fold in make_kfold_splits(records, n_folds=5, seed=SEED):
+        _assert_exclusion_is_subset(records, fold, ["train", "held_out"])
+
+
+def test_exclusion_keeps_strong_images_of_mixed_patient_in_same_split() -> None:
+    records = _mixed_records()
+    split = split_train_val_test(records, val_ratio=0.15, test_ratio=0.15, seed=SEED)
+    without_mild = split_records(records, split, WITHOUT_MILD)
+    for i in range(6):
+        pid = f"mixed_{i}"
+        homes = [name for name, rs in without_mild.items() if any(r.patient_id == pid for r in rs)]
+        assert len(homes) == 1
+        (home,) = homes
+        assert pid in split.parts()[home]
+        assert [r.severity for r in without_mild[home] if r.patient_id == pid] == ["strong"]
+
+
+def test_mild_exclusion_keeps_all_five_classes() -> None:
+    # SPEC_02: 「ややあり除外」でも 5 クラスすべてが残る
+    records = make_group_records(UNEVEN_GROUPS)
+    split = split_train_val_test(records, val_ratio=0.15, test_ratio=0.15, seed=SEED)
+    for name, rs in split_records(records, split, WITHOUT_MILD).items():
+        assert all(n > 0 for n in count_by_class(rs).values()), name
+
+
+@pytest.mark.parametrize("severities", [(), ("weak",), ("strong", "unknown")])
+def test_split_records_rejects_invalid_severities(severities: tuple[str, ...]) -> None:
+    records = make_group_records(UNEVEN_GROUPS)
+    split = split_train_val_test(records, val_ratio=0.15, test_ratio=0.15, seed=SEED)
+    with pytest.raises(ValueError):
+        split_records(records, split, severities)
+
+
+def test_filter_by_severity_keeps_only_given_severities() -> None:
+    records = _mixed_records()
+    assert filter_by_severity(records, WITHOUT_MILD) == [r for r in records if r.severity != "mild"]
+    assert filter_by_severity(records, ("mild",)) == [r for r in records if r.severity == "mild"]
+
+
+@pytest.mark.parametrize("severities", [(), ("weak",)])
+def test_filter_by_severity_rejects_invalid(severities: tuple[str, ...]) -> None:
+    with pytest.raises(ValueError):
+        filter_by_severity(make_group_records(UNEVEN_GROUPS), severities)
+
+
+def test_count_by_group_lists_all_nine_groups() -> None:
+    records = make_group_records({"red_mild": 2, "light_red_normal": 3}, images_per_patient=2)
+    counts = count_by_group(records)
+    assert list(counts) == list(ALL_DIR_NAMES)
+    assert counts["red_mild"] == 4
+    assert counts["light_red_normal"] == 6
+    assert sum(counts.values()) == 10
diff --git a/tests/data/test_survey.py b/tests/data/test_survey.py
new file mode 100644
index 0000000..225b46f
--- /dev/null
+++ b/tests/data/test_survey.py
@@ -0,0 +1,396 @@
+"""データセット集計のテスト（SPEC_01「データセット集計の出力」・SPEC_02「程度（ややあり）の扱い」）.
+
+- 出力には集計値だけを入れる．**画像単位の値・患者 ID・ファイル名を出さない**（ログも同様）
+- 読めない画像・欠けたファイルがあっても止めず，件数として数える
+- 舌領域（RGB がすべて 0 でない画素）の Lab を画像ごとに平均し，グループごとに集計する
+- 各 mild グループについて「淡紅（light_red_normal）との ΔE」と「同じクラスの strong との ΔE」を
+  並べる
+- 条件（ややあり込み／除外）ごとの件数と，既定の設定で分割したときの各分割・グループの件数
+
+画像はすべて tmp_path に作る合成画像（臨床データは使わない）．
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import pytest
+from PIL import Image
+
+from tias_judge_model.data.classes import ALL_DIR_NAMES, CLASS_SLUGS, parse_dir_name
+from tias_judge_model.data.color import delta_e_cie76, rgb8_to_lab
+from tias_judge_model.data.manifest import ManifestRecord
+from tias_judge_model.data.survey import (
+    ImageStats,
+    collect_image_stats,
+    measure_pixels,
+    summarize_dataset,
+)
+
+SECRET = "SECRETPT"
+SPLIT_KW: dict[str, Any] = {"seed": 42, "val_ratio": 0.15, "test_ratio": 0.15, "n_folds": 5}
+
+# 合成データ（scripts/make_synthetic_dataset.py）に近い基準色
+BASE = {
+    "pale": (235, 205, 200),
+    "light_red": (225, 140, 140),
+    "red": (215, 40, 45),
+    "dark_red": (120, 20, 30),
+    "purple": (110, 50, 140),
+}
+
+
+def _uniform(rgb: tuple[int, int, int], *, width: int = 20, height: int = 10) -> np.ndarray:
+    """全面が 1 色の舌領域の画像（`(H, W, 3)`, uint8）."""
+    pixels = np.zeros((height, width, 3), dtype=np.uint8)
+    pixels[:, :] = rgb
+    return pixels
+
+
+def _half_background(rgb: tuple[int, int, int]) -> np.ndarray:
+    """左半分が背景（黒），右半分が 1 色の画像."""
+    pixels = np.zeros((10, 20, 3), dtype=np.uint8)
+    pixels[:, 10:] = rgb
+    return pixels
+
+
+def _stats(pixels: np.ndarray) -> ImageStats:
+    return measure_pixels(pixels, mode="RGB", has_alpha=False)
+
+
+def _record(group: str, index: int, image_index: int = 0) -> ManifestRecord:
+    label, severity = parse_dir_name(group)
+    patient_id = f"{SECRET}{group}{index:04d}"
+    return ManifestRecord(
+        image_path=f"{group}/{patient_id}_{image_index}.png",
+        patient_id=patient_id,
+        label=label,
+        severity=severity,
+    )
+
+
+def _blend(a: tuple[int, int, int], b: tuple[int, int, int], t: float) -> tuple[int, int, int]:
+    """a と b を (1 - t) : t で混ぜた色."""
+    return tuple(int(round((1 - t) * x + t * y)) for x, y in zip(a, b, strict=True))  # type: ignore[return-value]
+
+
+def _dataset(per_group: int = 6) -> tuple[list[ManifestRecord], list[ImageStats], dict]:
+    """全 9 グループに per_group 人（1 人 1 枚）の合成データ．グループごとの色を返す."""
+    normal = BASE["light_red"]
+    colors: dict[str, tuple[int, int, int]] = {}
+    for group in ALL_DIR_NAMES:
+        label, severity = parse_dir_name(group)
+        if severity == "mild":
+            # red_mild・purple_mild は淡紅寄り，pale_mild・dark_red_mild は strong 寄り
+            t = 0.8 if label in ("red", "purple") else 0.1
+            colors[group] = _blend(BASE[label], normal, t)
+        else:
+            colors[group] = BASE[label]
+    records: list[ManifestRecord] = []
+    stats: list[ImageStats] = []
+    for group in ALL_DIR_NAMES:
+        for i in range(per_group):
+            records.append(_record(group, i))
+            stats.append(_stats(_uniform(colors[group], width=20 + i, height=10 + i)))
+    return records, stats, colors
+
+
+def _summarize(records: list[ManifestRecord], stats: list[ImageStats], **kw: Any) -> dict:
+    return summarize_dataset(
+        records, stats, **{**SPLIT_KW, **kw}, configured_severities=("strong", "mild", "normal")
+    )
+
+
+def _walk_lists(value: Any):
+    if isinstance(value, dict):
+        for v in value.values():
+            yield from _walk_lists(v)
+    elif isinstance(value, list):
+        yield value
+        for v in value:
+            yield from _walk_lists(v)
+
+
+# ---------------------------------------------------------------------------
+# 個人情報・画像単位の値を出さない
+# ---------------------------------------------------------------------------
+
+
+class TestNoPersonalData:
+    def test_summary_has_no_patient_id_or_filename(self) -> None:
+        records, stats, _ = _dataset()
+        summary = _summarize(records, stats)
+        text = json.dumps(summary, ensure_ascii=False)
+        assert SECRET not in text
+        assert ".png" not in text
+        for r in records:
+            assert r.patient_id not in text
+            assert r.image_path not in text
+        # 分割の確認も実際に行われていること（空振りで個人情報が出ないのではない）
+        assert "error" not in summary["split"]["single"]
+        assert all("error" not in fold for fold in summary["split"]["kfold"])
+
+    def test_summary_has_no_per_image_values(self) -> None:
+        # 画像単位の値の列（画像数と同じ長さのリスト等）を含まない
+        records, stats, _ = _dataset()
+        summary = _summarize(records, stats)
+        for lst in _walk_lists(summary):
+            assert len(lst) < len(records)
+        # JSON にできる（集計値だけの dict）
+        json.dumps(summary)
+
+    def test_logs_have_no_patient_id_or_filename(
+        self, tmp_path: Path, caplog: pytest.LogCaptureFixture
+    ) -> None:
+        caplog.set_level(logging.DEBUG)
+        records, _, colors = _dataset(per_group=2)
+        images = tmp_path / "images"
+        for r in records[:6]:
+            path = images / r.image_path
+            path.parent.mkdir(parents=True, exist_ok=True)
+            Image.fromarray(_uniform(colors[f"{r.label}_{r.severity}"])).save(path)
+        broken = images / records[6].image_path
+        broken.parent.mkdir(parents=True, exist_ok=True)
+        broken.write_bytes(b"not a png")
+        # records[7:] は欠けたファイル
+        stats = collect_image_stats(records, images)
+        _summarize(records, stats)
+        assert SECRET not in caplog.text
+        assert ".png" not in caplog.text
+
+
+# ---------------------------------------------------------------------------
+# 読み込み（読めない画像・欠けたファイルで止まらない）
+# ---------------------------------------------------------------------------
+
+
+class TestLoading:
+    def _write_images(self, images: Path) -> list[ManifestRecord]:
+        recs = [_record("red_strong", i) for i in range(6)]
+        paths = [images / r.image_path for r in recs]
+        paths[0].parent.mkdir(parents=True)
+        Image.fromarray(_uniform((200, 50, 50))).save(paths[0])  # RGB
+        rgba = np.zeros((10, 20, 4), dtype=np.uint8)
+        rgba[..., 0] = 200
+        rgba[..., 3] = 255
+        Image.fromarray(rgba, mode="RGBA").save(paths[1])  # アルファ付き
+        Image.fromarray(np.full((10, 20), 128, dtype=np.uint8), mode="L").save(paths[2])  # 濃淡
+        paths[3].write_bytes(b"\x89PNG\r\n\x1a\n broken")  # 壊れた PNG
+        paths[4].write_bytes(b"")  # 空ファイル
+        # paths[5] は作らない（欠けたファイル）
+        return recs
+
+    def test_unreadable_and_missing_are_counted_not_raised(self, tmp_path: Path) -> None:
+        images = tmp_path / "images"
+        records = self._write_images(images)
+        stats = collect_image_stats(records, images)
+        assert len(stats) == len(records)
+        summary = _summarize(records, stats)
+        loading = summary["loading"]
+        assert loading["readable"] == 3
+        assert loading["unreadable"] == 3
+        assert loading["missing"] == 1
+        assert loading["with_alpha"] == 1
+        assert loading["non_rgb_mode"] == 2  # RGBA と L
+        # 読めない画像も件数（manifest 上の画像数）には入る
+        assert summary["counts"]["groups"]["red_strong"]["images"] == 6
+        # 色の集計は読めた画像だけ
+        assert summary["lab"]["groups"]["red_strong"]["n"] == 3
+
+    def test_size_summary(self) -> None:
+        records = [_record("red_strong", i) for i in range(3)]
+        stats = [
+            _stats(_uniform((200, 50, 50), width=w, height=h))
+            for w, h in [(10, 40), (30, 20), (50, 30)]
+        ]
+        size = _summarize(records, stats)["size"]
+        assert size["width"] == pytest.approx({"min": 10, "max": 50, "mean": 30, "median": 30})
+        assert size["height"] == pytest.approx({"min": 20, "max": 40, "mean": 30, "median": 30})
+
+    def test_tongue_ratio_excludes_background(self) -> None:
+        records = [_record("red_strong", 0), _record("red_strong", 1)]
+        stats = [_stats(_half_background((200, 50, 50))), _stats(_uniform((200, 50, 50)))]
+        ratio = _summarize(records, stats)["tongue_ratio"]
+        assert ratio["total"] == pytest.approx({"min": 0.5, "mean": 0.75, "max": 1.0})
+
+
+# ---------------------------------------------------------------------------
+# 色（Lab）と色差
+# ---------------------------------------------------------------------------
+
+
+class TestLabAndDeltaE:
+    def test_background_does_not_affect_lab(self) -> None:
+        records = [_record("red_strong", 0)]
+        stats = [_stats(_half_background((255, 255, 255)))]
+        lab = _summarize(records, stats)["lab"]["groups"]["red_strong"]
+        assert lab["n"] == 1
+        assert lab["L"]["mean"] == pytest.approx(100.0, abs=1e-3)
+        assert lab["a"]["mean"] == pytest.approx(0.0, abs=1e-3)
+        assert lab["b"]["mean"] == pytest.approx(0.0, abs=1e-3)
+
+    def test_group_statistics_over_image_means(self) -> None:
+        # 画像ごとの平均 Lab をグループで集計する．灰色 3 枚（L* が既知）
+        grays = [50, 119, 200]
+        records = [_record("pale_strong", i) for i in range(3)]
+        stats = [_stats(_uniform((v, v, v))) for v in grays]
+        expected = [float(rgb8_to_lab(np.array([v, v, v], dtype=np.uint8))[0]) for v in grays]
+        lab = _summarize(records, stats)["lab"]["groups"]["pale_strong"]
+        assert lab["n"] == 3
+        assert lab["L"]["mean"] == pytest.approx(np.mean(expected), abs=1e-3)
+        assert lab["L"]["median"] == pytest.approx(expected[1], abs=1e-3)
+        assert lab["L"]["p10"] == pytest.approx(np.percentile(expected, 10), abs=1e-3)
+        assert lab["L"]["p90"] == pytest.approx(np.percentile(expected, 90), abs=1e-3)
+        assert lab["L"]["std"] is not None and lab["L"]["std"] > 0
+        assert lab["a"]["mean"] == pytest.approx(0.0, abs=1e-3)
+        # 画像の無いグループは件数 0
+        assert _summarize(records, stats)["lab"]["groups"]["red_mild"]["n"] == 0
+
+    def test_mild_comparison_with_known_colors(self) -> None:
+        records, stats, colors = _dataset()
+        summary = _summarize(records, stats)
+        lab_of = {g: rgb8_to_lab(np.array(c, dtype=np.uint8)) for g, c in colors.items()}
+        items = {item["group"]: item for item in summary["delta_e"]["mild_comparison"]}
+        assert set(items) == {"pale_mild", "red_mild", "dark_red_mild", "purple_mild"}
+        for group, item in items.items():
+            label, _ = parse_dir_name(group)
+            to_normal = delta_e_cie76(lab_of[group], lab_of["light_red_normal"])
+            to_strong = delta_e_cie76(lab_of[group], lab_of[f"{label}_strong"])
+            assert item["delta_e_to_normal"] == pytest.approx(to_normal, abs=1e-3), group
+            assert item["delta_e_to_strong"] == pytest.approx(to_strong, abs=1e-3), group
+        # 淡紅寄りに作った mild は淡紅に，strong 寄りに作った mild は strong に近い
+        assert items["red_mild"]["closer_to"] == "light_red_normal"
+        assert items["purple_mild"]["closer_to"] == "light_red_normal"
+        assert items["pale_mild"]["closer_to"] == "pale_strong"
+        assert items["dark_red_mild"]["closer_to"] == "dark_red_strong"
+
+    def test_group_mean_is_average_of_images(self) -> None:
+        # red_mild に色の異なる 2 枚．グループ平均は画像ごとの Lab の平均で，ΔE はそれとの距離
+        normal = (225, 140, 140)
+        c1, c2 = (220, 100, 100), (200, 60, 60)
+        records = [
+            _record("light_red_normal", 0),
+            _record("red_mild", 0),
+            _record("red_mild", 1),
+            _record("red_strong", 0),
+        ]
+        stats = [_stats(_uniform(c)) for c in (normal, c1, c2, BASE["red"])]
+        item = next(
+            i
+            for i in _summarize(records, stats)["delta_e"]["mild_comparison"]
+            if i["group"] == "red_mild"
+        )
+        lab = {c: rgb8_to_lab(np.array(c, dtype=np.uint8)) for c in (normal, c1, c2, BASE["red"])}
+        mild_mean = (lab[c1] + lab[c2]) / 2
+        assert item["delta_e_to_normal"] == pytest.approx(
+            delta_e_cie76(mild_mean, lab[normal]), abs=1e-3
+        )
+        assert item["delta_e_to_strong"] == pytest.approx(
+            delta_e_cie76(mild_mean, lab[BASE["red"]]), abs=1e-3
+        )
+
+    def test_matrix_is_symmetric_with_zero_diagonal(self) -> None:
+        records, stats, _ = _dataset(per_group=2)
+        matrix = _summarize(records, stats)["delta_e"]["matrix"]
+        for g1 in ALL_DIR_NAMES:
+            assert matrix[g1][g1] == pytest.approx(0.0)
+            for g2 in ALL_DIR_NAMES:
+                assert matrix[g1][g2] == pytest.approx(matrix[g2][g1])
+
+
+# ---------------------------------------------------------------------------
+# 件数・条件・分割の確認
+# ---------------------------------------------------------------------------
+
+
+class TestCounts:
+    def test_counts_by_group_class_severity_and_condition(self) -> None:
+        records, stats, _ = _dataset(per_group=6)
+        # 1 患者 2 枚（strong と mild）の患者を足す
+        extra = [
+            ManifestRecord("red_strong/x_0.png", f"{SECRET}mix", "red", "strong"),
+            ManifestRecord("red_mild/x_1.png", f"{SECRET}mix", "red", "mild"),
+        ]
+        records = [*records, *extra]
+        stats = [*stats, _stats(_uniform((200, 50, 50))), _stats(_uniform((210, 90, 90)))]
+        counts = _summarize(records, stats)["counts"]
+
+        assert counts["total"] == {"images": 56, "patients": 55}
+        assert counts["groups"]["red_strong"]["images"] == 7
+        assert counts["groups"]["red_mild"]["images"] == 7
+        assert counts["groups"]["pale_mild"] == {
+            "label": "pale",
+            "severity": "mild",
+            "images": 6,
+            "patients": 6,
+        }
+        assert set(counts["groups"]) == set(ALL_DIR_NAMES)
+        assert counts["classes"]["red"] == {"images": 14, "patients": 13}
+        assert counts["classes"]["light_red"] == {"images": 6, "patients": 6}
+        assert counts["severities"]["mild"]["images"] == 25
+        assert counts["severities"]["normal"]["images"] == 6
+
+        with_mild = counts["conditions"]["with_mild"]
+        without_mild = counts["conditions"]["without_mild"]
+        assert with_mild["images"] == 56
+        assert without_mild["images"] == 56 - 25
+        # mix 患者は strong の画像が残るため患者数に入る
+        assert without_mild["patients"] == 4 * 6 + 6 + 1
+        # 除外後も 5 クラスすべてが残る
+        assert set(without_mild["classes"]) == set(CLASS_SLUGS)
+        assert all(n > 0 for n in without_mild["classes"].values())
+        assert without_mild["classes"]["red"] == 7
+
+    def test_split_counts_follow_default_settings(self) -> None:
+        records, stats, _ = _dataset(per_group=10)
+        split = _summarize(records, stats)["split"]
+        assert (split["seed"], split["n_folds"]) == (42, 5)
+        single = split["single"]
+        # 各グループの件数を分割で足すと全体の件数に一致し，各分割に 9 グループが入る
+        for group in ALL_DIR_NAMES:
+            assert sum(single["groups"][part][group] for part in ("train", "val", "test")) == 10
+            for part in ("train", "val", "test"):
+                assert single["groups"][part][group] > 0, (part, group)
+        # val / test はグループごとに 10 × 0.15 = 1.5 → 2 人
+        for part in ("val", "test"):
+            assert all(n == 2 for n in single["groups"][part].values())
+        assert sum(single["patients"].values()) == len(records)
+        assert len(split["kfold"]) == 5
+
+    def test_split_conditions_are_subsets(self) -> None:
+        # 「ややあり除外」の各分割の件数 = 「ややあり込み」の件数 − その分割の mild の件数
+        records, stats, _ = _dataset(per_group=10)
+        split = _summarize(records, stats)["split"]
+        cases = [(split["single"], ("train", "val", "test"))]
+        cases += [(fold, ("train", "held_out")) for fold in split["kfold"]]
+        for summary, parts in cases:
+            for part in parts:
+                groups = summary["groups"][part]
+                mild = sum(n for g, n in groups.items() if parse_dir_name(g)[1] == "mild")
+                with_mild = summary["conditions"]["with_mild"][part]["images"]
+                without_mild = summary["conditions"]["without_mild"][part]["images"]
+                assert with_mild == sum(groups.values())
+                assert without_mild == with_mild - mild
+
+    def test_split_error_does_not_stop_summary(self) -> None:
+        # 分割できない構成（グループの人数が少ない）でも集計は止めない
+        records, stats, _ = _dataset(per_group=2)
+        summary = _summarize(records, stats)
+        assert "error" in summary["split"]["kfold"]
+        assert SECRET not in json.dumps(summary, ensure_ascii=False)
+
+    def test_configured_severities_are_recorded(self) -> None:
+        records, stats, _ = _dataset(per_group=6)
+        summary = summarize_dataset(
+            records, stats, **SPLIT_KW, configured_severities=("strong", "normal")
+        )
+        assert summary["configured_severities"] == ["strong", "normal"]
+
+    def test_length_mismatch_is_error(self) -> None:
+        records, stats, _ = _dataset(per_group=2)
+        with pytest.raises(ValueError):
+            _summarize(records, stats[:-1])
diff --git a/tests/remote/test_commands.py b/tests/remote/test_commands.py
index 58c2d47..859dabc 100644
--- a/tests/remote/test_commands.py
+++ b/tests/remote/test_commands.py
@@ -6,8 +6,10 @@
 
 from tias_judge_model.remote.commands import (
     build_job_env,
+    build_job_script,
     build_probe_command,
     build_ssh_argv,
+    format_git_commit,
     validate_job_name,
 )
 
@@ -112,3 +114,92 @@
         assert env["CUDA_VISIBLE_DEVICES"] == "2"
         assert env["FOO"] == "bar"
         assert env["EMPTY"] == ""
+
+
+class TestGitCommit:
+    """`TIAS_GIT_COMMIT`（SPEC_03「run」・SPEC_01「実験の出力」）."""
+
+    def test_clean_tree_passes_short_hash(self) -> None:
+        # git rev-parse --short HEAD の出力（末尾改行付き）
+        assert format_git_commit("abc1234\n", dirty=False) == "abc1234"
+
+    def test_dirty_tree_appends_suffix(self) -> None:
+        assert format_git_commit("abc1234\n", dirty=True) == "abc1234-dirty"
+
+    def test_job_env_contains_git_commit(self) -> None:
+        env = build_job_env(0, [], git_commit="abc1234-dirty")
+        assert env["TIAS_GIT_COMMIT"] == "abc1234-dirty"
+
+    def test_job_env_without_git_commit_does_not_set_it(self) -> None:
+        env = build_job_env(0, [])
+        assert "TIAS_GIT_COMMIT" not in env
+
+    @pytest.mark.parametrize("git_commit", ["abc1234", None])
+    def test_env_option_cannot_override_git_commit(self, git_commit: str | None) -> None:
+        # git が使えず渡さないときも --env で指定させない（実験の記録を迂回させないため）
+        with pytest.raises(ValueError):
+            build_job_env(0, ["TIAS_GIT_COMMIT=fake"], git_commit=git_commit)
+
+
+class TestReservedEnv:
+    @pytest.mark.parametrize(
+        "key",
+        [
+            "CUDA_VISIBLE_DEVICES",
+            "TIAS_DATA_ROOT",
+            "CUDA_DEVICE_ORDER",
+            "PYTHONUNBUFFERED",
+            "TIAS_GIT_COMMIT",
+        ],
+    )
+    @pytest.mark.parametrize("gpu_index", [0, None])
+    def test_reserved_keys_cannot_be_overridden(self, key: str, gpu_index: int | None) -> None:
+        with pytest.raises(ValueError):
+            build_job_env(gpu_index, [f"{key}=x"], git_commit="abc1234")
+
+    def test_fixed_values(self) -> None:
+        env = build_job_env(3, [], git_commit="abc1234")
+        assert env["CUDA_DEVICE_ORDER"] == "PCI_BUS_ID"
+        assert env["PYTHONUNBUFFERED"] == "1"
+        assert env["CUDA_VISIBLE_DEVICES"] == "3"
+
+
+class TestCpuJob:
+    """`run --cpu`（SPEC_03「run」）.
+
+    CUDA_VISIBLE_DEVICES を空文字で渡し，ログの開始行の GPU は「なし（CPU）」とする．
+    """
+
+    def test_cpu_job_env_hides_gpus(self) -> None:
+        env = build_job_env(None, ["FOO=bar"], git_commit="abc1234")
+        assert "CUDA_VISIBLE_DEVICES" in env
+        assert env["CUDA_VISIBLE_DEVICES"] == ""
+        assert env["CUDA_DEVICE_ORDER"] == "PCI_BUS_ID"
+        assert env["TIAS_GIT_COMMIT"] == "abc1234"
+        assert env["FOO"] == "bar"
+
+    def _script(self, gpu_index: int | None) -> str:
+        return build_job_script(
+            "~/work/TIASJudgeModel",
+            "survey",
+            ["tias-dataset", "survey", "--config", "configs/newton.yaml"],
+            uv_path="~/.local/bin/uv",
+            server_name="Newton",
+            gpu_index=gpu_index,
+            env=build_job_env(gpu_index, [], git_commit="abc1234"),
+            path_env={"TIAS_DATA_ROOT": "~/data/TIASJudgeModel"},
+        )
+
+    def test_cpu_job_log_header_says_no_gpu(self) -> None:
+        script = self._script(None)
+        assert "gpu=なし（CPU）" in script
+        assert "gpu=None" not in script
+        # 空文字として export する（未設定ではなく空にして GPU を見えなくする）
+        assert "export CUDA_VISIBLE_DEVICES=''" in script
+
+    def test_gpu_job_log_header_has_index(self) -> None:
+        script = self._script(1)
+        assert "gpu=1" in script
+        assert "なし（CPU）" not in script
+        assert "export CUDA_VISIBLE_DEVICES=1" in script
+        assert "export TIAS_GIT_COMMIT=abc1234" in script
diff --git a/tests/remote/test_gpu.py b/tests/remote/test_gpu.py
index bf80327..1adb352 100644
--- a/tests/remote/test_gpu.py
+++ b/tests/remote/test_gpu.py
@@ -18,10 +18,12 @@
     GpuState,
     ProbeOutput,
     ServerProbe,
+    check_cpu_options,
     check_selection_options,
     classify_gpu,
     gpu_users,
     parse_probe_output,
+    select_cpu_server,
     select_gpu,
 )
 from tias_judge_model.remote.observe import UsagePattern
@@ -460,3 +462,79 @@
         check_selection_options(server_name="Newton", gpu_index=0, force=False)
         check_selection_options(server_name="Newton", gpu_index=0, force=True)
         check_selection_options(server_name=None, gpu_index=None, force=False)
+
+
+# ---------------------------------------------------------------------------
+# run --cpu（SPEC_03「run」）
+# ---------------------------------------------------------------------------
+
+
+class TestCheckCpuOptions:
+    def test_cpu_alone_is_accepted(self) -> None:
+        check_cpu_options(gpu_index=None, force=False, observe_sec=None)
+
+    @pytest.mark.parametrize(
+        ("gpu_index", "force", "observe_sec"),
+        [(0, False, None), (None, True, None), (None, False, 0), (None, False, 10), (1, True, 5)],
+    )
+    def test_gpu_related_options_conflict(
+        self, gpu_index: int | None, force: bool, observe_sec: int | None
+    ) -> None:
+        with pytest.raises(ValueError):
+            check_cpu_options(gpu_index=gpu_index, force=force, observe_sec=observe_sec)
+
+
+class TestSelectCpuServer:
+    def test_gpu_state_is_ignored(self) -> None:
+        # GPU がすべて使用中・状態不明・一覧取得失敗でも，接続できれば選ぶ
+        probes = [_probe(NEWTON, B, X), _probe(ARCHIMEDES, U)]
+        assert select_cpu_server(probes).name == "Newton"
+        probes = [_probe(NEWTON, gpu_query_ok=False), _probe(ARCHIMEDES, U)]
+        assert select_cpu_server(probes).name == "Newton"
+
+    def test_priority_order(self) -> None:
+        # 設定の記載順ではなく priority 順
+        probes = [_probe(ARCHIMEDES, U), _probe(NEWTON, B)]
+        assert select_cpu_server(probes).name == "Newton"
+
+    def test_same_priority_uses_config_order(self) -> None:
+        a, b = _server("A", 1), _server("B", 1)
+        assert select_cpu_server([_probe(b, U), _probe(a, U)]).name == "B"
+
+    def test_unreachable_is_skipped(self) -> None:
+        probes = [_unreachable(NEWTON), _probe(ARCHIMEDES, B)]
+        assert select_cpu_server(probes).name == "Archimedes"
+
+    def test_all_unreachable_is_none(self) -> None:
+        assert select_cpu_server([_unreachable(NEWTON), _unreachable(ARCHIMEDES)]) is None
+
+    def test_data_not_ready_is_excluded_by_default(self) -> None:
+        newton = _server("Newton", 1, data_ready=False)
+        probes = [_probe(newton, U), _probe(ARCHIMEDES, B)]
+        assert select_cpu_server(probes).name == "Archimedes"
+        assert select_cpu_server([_probe(newton, U)]) is None
+
+    def test_no_data_includes_not_ready(self) -> None:
+        newton = _server("Newton", 1, data_ready=False)
+        probes = [_probe(newton, U), _probe(ARCHIMEDES, B)]
+        assert select_cpu_server(probes, include_not_ready=True).name == "Newton"
+
+    def test_explicit_server(self) -> None:
+        probes = [_probe(NEWTON, U), _probe(ARCHIMEDES, B)]
+        assert select_cpu_server(probes, server_name="Archimedes").name == "Archimedes"
+
+    def test_explicit_unreachable_server_is_error(self) -> None:
+        probes = [_probe(NEWTON, U), _unreachable(ARCHIMEDES)]
+        with pytest.raises(ValueError):
+            select_cpu_server(probes, server_name="Archimedes")
+
+    def test_explicit_not_ready_server_requires_no_data(self) -> None:
+        newton = _server("Newton", 1, data_ready=False)
+        probes = [_probe(newton, U), _probe(ARCHIMEDES, U)]
+        with pytest.raises(ValueError):
+            select_cpu_server(probes, server_name="Newton")
+        assert select_cpu_server(probes, server_name="Newton", include_not_ready=True) is newton
+
+    def test_unknown_server_is_error(self) -> None:
+        with pytest.raises(ValueError):
+            select_cpu_server([_probe(NEWTON, U)], server_name="Euler")
diff --git a/tests/remote/test_whitelist.py b/tests/remote/test_whitelist.py
index 9854ce6..811874d 100644
--- a/tests/remote/test_whitelist.py
+++ b/tests/remote/test_whitelist.py
@@ -19,7 +19,14 @@
 
 RUN_ID = "20260927-120000_newton_abc1234"
 
-ROOT_FILES = ["config.yaml", "history.csv", "metrics.json", "confusion_matrix.csv", "log.txt"]
+ROOT_FILES = [
+    "config.yaml",
+    "history.csv",
+    "metrics.json",
+    "confusion_matrix.csv",
+    "log.txt",
+    "dataset_summary.json",  # データセット集計の結果（集計値のみ）
+]
 
 # 列挙外（回収してはならない）ファイル．患者 ID・画像名を含みうる名前も混ぜる
 NOT_ALLOWED = [
@@ -43,6 +50,12 @@
     "checkpoints/best.pth",
     "checkpoints/sub/best.pt",
     "best.pt",
+    # データセット集計の名前に似ているが列挙外のもの
+    "dataset_summary.csv",
+    "dataset_summary.json.bak",
+    "figures/dataset_summary.json",
+    "sub/dataset_summary.json",
+    "dataset_details.json",
 ]
 
 
diff --git a/tests/test_schema.py b/tests/test_schema.py
index eb07514..825ffa3 100644
--- a/tests/test_schema.py
+++ b/tests/test_schema.py
@@ -118,3 +118,44 @@
 def test_non_mapping_yaml_is_rejected(tmp_path: Path) -> None:
     with pytest.raises(ValueError):
         load_config(_write(tmp_path, "- a\n- b\n"), environ={})
+
+
+# --- data.severities（SPEC_01「設定ファイル」・SPEC_02「程度（ややあり）の扱い」） ---
+
+
+def test_severities_default_is_all_three(tmp_path: Path) -> None:
+    config = load_config(_write(tmp_path, "data:\n  root: d\n"), environ={})
+    assert set(config.data.severities) == {"strong", "mild", "normal"}
+    assert len(config.data.severities) == 3
+
+
+@pytest.mark.parametrize(
+    ("value", "expected"),
+    [
+        ("[strong, normal]", {"strong", "normal"}),  # ややあり除外
+        ("[strong, mild, normal]", {"strong", "mild", "normal"}),  # ややあり込み
+        ("[normal, strong]", {"strong", "normal"}),  # 記載順は問わない
+        ("[mild]", {"mild"}),
+    ],
+)
+def test_valid_severities_are_accepted(tmp_path: Path, value: str, expected: set[str]) -> None:
+    config = load_config(_write(tmp_path, f"data:\n  root: d\n  severities: {value}\n"), environ={})
+    assert set(config.data.severities) == expected
+    assert len(config.data.severities) == len(expected)
+
+
+@pytest.mark.parametrize(
+    "value",
+    [
+        "[]",  # 空
+        "[strong, strong]",  # 重複
+        "[strong, normal, strong]",  # 重複
+        "[weak]",  # 未知の値
+        "[strong, Mild]",  # 大文字違いも未知の値
+        "[strong, ややあり]",
+    ],
+)
+def test_invalid_severities_are_rejected(tmp_path: Path, value: str) -> None:
+    text = f"data:\n  root: d\n  severities: {value}\n"
+    with pytest.raises(ValidationError):
+        load_config(_write(tmp_path, text), environ={})