diff --git a/.gitignore b/.gitignore
index 7ee90c9..124e4b3 100644
--- a/.gitignore
+++ b/.gitignore
@@ -25,7 +25,7 @@
 # --- プロジェクト固有 ---
 
 # 臨床データ・合成データ（絶対にコミットしない）
-data/
+/data/
 
 # 学習結果（指標・図・チェックポイント）
 runs/
diff --git a/CLAUDE.md b/CLAUDE.md
index 6e3cd7f..f68986e 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -5,7 +5,7 @@
 
 ## 開発進捗
 
-最新: 臨床データ 1085 枚を Newton へ転送完了．次は PLAN_02 の Step 1（基盤: 設定スキーマ・合成データ・manifest・患者単位分割）
+最新: PLAN_02 Step 1（基盤: 設定スキーマ・manifest・患者単位分割・合成データ生成）完了．次は Step 2（リモート実行ツール）
 ※ 本欄は**最新ステップ 1 行のみ上書き更新**．詳細な進捗履歴（動機・設計判断・失敗パターン）は [docs/PROGRESS.md](docs/PROGRESS.md) に追記する．運用ルールは `.claude/rules/progress-log.md` を参照（該当ファイル編集時に自動ロードされる）．
 
 ## 必須ルール（コード実装時）
diff --git a/configs/newton.yaml b/configs/newton.yaml
new file mode 100644
index 0000000..f7908cd
--- /dev/null
+++ b/configs/newton.yaml
@@ -0,0 +1,12 @@
+# 計算サーバ（Newton）上の実データを指す設定（SPEC_01「データ契約」）
+# 臨床データはサーバ上にのみ置く．手元ではこの設定で実行しない．
+# 環境変数 TIAS_DATA_ROOT が設定されていれば data.root より優先される．
+data:
+  root: ~/data/TIASJudgeModel
+  manifest: manifest.csv # data.root からの相対パス
+
+split:
+  seed: 42
+  val_ratio: 0.15
+  test_ratio: 0.15
+  n_folds: 5
diff --git a/configs/synthetic.yaml b/configs/synthetic.yaml
new file mode 100644
index 0000000..7abc709
--- /dev/null
+++ b/configs/synthetic.yaml
@@ -0,0 +1,12 @@
+# 手元確認用: 合成データ（scripts/make_synthetic_dataset.py の出力）を指す設定
+# data.root の相対パスはカレントディレクトリ（リポジトリのルート）基準．
+# 環境変数 TIAS_DATA_ROOT が設定されていれば data.root より優先される．
+data:
+  root: data/synthetic
+  manifest: manifest.csv # data.root からの相対パス
+
+split:
+  seed: 42
+  val_ratio: 0.15
+  test_ratio: 0.15
+  n_folds: 5
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 16988fe..e8deebd 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"
@@ -3,6 +3,7 @@
 日常の開発で使うコマンドの一覧．**コマンドを推測せず必ず本ファイルを参照する**（新しく確定・変更された時は本ファイルに反映する）．
 
 ※ 学習・評価・リモート実行のコマンドは未実装のため本ファイルには未記載（実装時に追記する）．
+※ Git Bash ではログの日本語が文字化けする．先頭に `PYTHONIOENCODING=utf-8` を付けると正しく表示される．
 
 ## 環境 (Environment)
 
@@ -13,12 +14,22 @@
 | 開発用依存の追加 | `uv add --dev <パッケージ>` | pytest・ruff 等 |
 | Python の実行 | `uv run python <スクリプト>` | 仮想環境を明示的に有効化しなくてよい |
 
+## データ (Data)
+
+| 目的 | コマンド | 備考 |
+| --- | --- | --- |
+| 合成データの生成 | `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` で変更できる |
+
+設定ファイルは `configs/synthetic.yaml`（手元の合成データ）と `configs/newton.yaml`（サーバの実データ）．環境変数 `TIAS_DATA_ROOT` を設定すると `data.root` より優先される．
+
 ## テスト (Test)
 
 | 目的 | コマンド |
 | --- | --- |
 | 全テスト | `uv run pytest` |
-| 特定ファイル | `uv run pytest tests/test_package.py` |
+| 特定ファイル | `uv run pytest tests/data/test_split.py` |
 | 詳細表示 | `uv run pytest -v` |
 
 臨床データに依存するテストは書かない（合成データで動くテストのみ）．
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 461c9e5..f8d61b8 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"
@@ -6,7 +6,7 @@
 
 | Step | 内容 | 前提 |
 | --- | --- | --- |
-| 1 | 基盤: 設定スキーマ・合成データ生成・manifest 読み込み・患者単位分割 | なし（手元で完結） |
+| 1 | 基盤: 設定スキーマ・合成データ生成・manifest 読み込み・患者単位分割 ✅ 完了 | なし（手元で完結） |
 | 2 | リモート実行ツール（送信・実行・回収・GPU 確認，回収ホワイトリスト） | Step 1 |
 | 3 | データセット集計（実データの素性把握） | **臨床データのコピー完了**・倫理確認 |
 | 4 | 学習パイプライン最小版（ConvNeXt-Tiny を 1 本通す） | Step 2・3 |
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 254ef24..d7986a6 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"
@@ -64,6 +64,33 @@
 - **`patient_id` について**: 現在のデータセットは 1 患者 1 枚であることを確認済み（2026-09-27）．したがって画像 ID をそのまま `patient_id` とする．**この前提が崩れる（同一患者の複数枚が追加される）場合は，実際の患者 ID を入れ直す必要がある**（同一患者が分割を跨ぐと評価が壊れるため）．分割処理は常に `patient_id` 単位で行い，前提が変わってもコードを変えずに済むようにする
 - 前提が確認できない新規データに対しては，画像 ID を患者 ID と見なす代替を**自動では行わない**．生成を止めて人間が判断する
 
+### manifest の検証規則 (Validation Rules)
+
+読み込み時・生成時とも，問題があれば**黙って除外せず `ValueError` で停止する**（`.claude/rules/error-handling.md`）．メッセージは行番号・件数・クラス名のみで示し，患者 ID・ファイル名を含めない．
+
+| 対象 | 停止する条件 |
+| --- | --- |
+| 読み込み | 必須列（`image_path`・`patient_id`・`label`・`severity`）の欠落，`patient_id` が空，未知の `label` / `severity`，無効な組み合わせ，`image_path` の重複，同一 `patient_id` に異なる `label`，`image_path` が絶対パス・`..` を含む・区切りが `\` |
+| 生成 | `images/` 直下の想定外のディレクトリ名・ファイル，クラスディレクトリ内のサブディレクトリ・PNG 以外のファイル，**画像が 0 枚のクラスディレクトリ**（クラスが欠けたまま学習が進むのを防ぐため），ファイル名の stem の重複（患者 ID と見なせなくなるため） |
+
+- `note` 列は読み込み時に省略できる（無ければ空文字）
+- 同一 `patient_id` で同じ `label` の複数行は許す（1 患者複数枚に備える）
+
+## 設定ファイル (Configuration)
+
+実験条件は `configs/*.yaml` に置き，pydantic で検証する（未知のキーは拒否する）．
+
+| キー | 内容 | 既定値 |
+| --- | --- | --- |
+| `data.root` | データのルート（`images/` と manifest を含む）．`~` を展開する．相対パスはカレントディレクトリ基準 | なし（必須） |
+| `data.manifest` | manifest のパス．相対パスは `data.root` 基準 | `manifest.csv` |
+| `split.seed` | 分割の seed | 42 |
+| `split.val_ratio`・`split.test_ratio` | 単一分割の比率．各 0 より大きく，合計 1 未満 | 0.15・0.15 |
+| `split.n_folds` | 交差検証の fold 数（2 以上） | 5 |
+
+- **環境変数 `TIAS_DATA_ROOT` が設定されていれば `data.root` より優先する**（サーバと手元で同じ設定ファイルを使い回せるようにするため）
+- 学習・モデル関連の設定は Step 4 で追加する
+
 ## クラス定義 (Class Definition)
 
 内部表現は英字 slug，表示は日本語とし，整数 ID を固定して混同行列の軸をぶらさない．
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 bca109b..7bf7771 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"
@@ -44,6 +44,11 @@
 - 分割は `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 数に満たないクラスがあれば停止する
+  - どちらも最初に患者 ID を並べ替えるため，manifest の行順に依存しない
+- 分割結果（各分割の患者 ID）は**個票に当たるため手元へ回収しない**（サーバ上の `runs/` にのみ保存する．[SPEC_01](SPEC_01_アーキテクチャ設計.md)「回収ホワイトリスト」）
 
 ## クラス不均衡 (Class Imbalance)
 
diff --git a/docs/PROGRESS.md b/docs/PROGRESS.md
index 3030b21..88cc78f 100644
--- a/docs/PROGRESS.md
+++ b/docs/PROGRESS.md
@@ -57,3 +57,12 @@
   - 実装上の注意: PowerShell はネイティブコマンドの引数を展開しないため `scp "...\*.png"` は使えない．ファイルを列挙して 100 件ずつ渡す（コマンドライン長の上限対策）．日本語フォルダ名は `<label>_<severity>` の ASCII スラッグへ対応付けて転送した
   - ユーザー確認事項の反映: データ利用は問題なし・1 患者 1 枚は確定・撮影は TIAS・セグメンテーションは専用の機械学習モデルによる自動処理（TEST_01 に記録）．ベースライン比較（Step 6）は入力条件を揃える設計判断が必要なため一旦後回しとした
 
+## Step 1: 基盤
+
+- [x] **設定スキーマ・クラス定義・manifest の生成/検証・患者単位分割・合成データ生成を実装**: 実データと同じ `images/<label>_<severity>/` 構成を前提に，manifest を学習の唯一の入口とする土台を作った．仕様は [SPEC_01](04_SPEC/SPEC_01_アーキテクチャ設計.md)「manifest の検証規則」「設定ファイル」と [SPEC_02](04_SPEC/SPEC_02_学習・評価仕様.md)「データ分割」に反映した．
+  - 設計判断: 1 患者 1 ラベルを manifest の検証で保証し，**患者の一覧をクラスで層化して分ける**方式にした（これで「患者単位」と「クラス層化」が同時に成り立つ）．K-fold は `StratifiedGroupKFold` ではなく患者一覧への `StratifiedKFold` を使う（1 患者 1 ラベルなら層化がより正確）
+  - 設計判断: 合成データの `--overwrite` は生成時の目印ファイルがある場所だけを消す（`--out` の指定ミスで実データを消す事故を防ぐ）
+  - 発見 ①: `.gitignore` の `data/` がパッケージ本体 `src/tias_judge_model/data/` にも一致し，**パッケージが Git に入らない状態だった** → `/data/`（リポジトリ直下のみ）に修正
+  - 発見 ②: サブエージェントの「ruff 通過」報告が実際と食い違っていた（行長エラー 2 件）．以後，lint・テストの成否は司令塔が自分で実行して確認する
+  - 判断: 画像が 0 枚のクラスディレクトリは当初警告のみで続行していたが，クラスが欠けたまま学習が進むのを防ぐため**エラーで停止する**よう仕様（SPEC_01）と実装を変更した（ユーザー判断）．大文字の拡張子 `.PNG` は受け付けたままとする（実データはすべて小文字で実害なし）
+
diff --git a/scripts/make_synthetic_dataset.py b/scripts/make_synthetic_dataset.py
new file mode 100644
index 0000000..1e7a150
--- /dev/null
+++ b/scripts/make_synthetic_dataset.py
@@ -0,0 +1,179 @@
+"""合成データセットを生成する（手元で実データと同じコードパスを流すため）.
+
+実データと同じ構成 `<out>/images/<label>_<severity>/*.png` と `<out>/manifest.csv` を作る．
+画像は黒背景 (0, 0, 0) の RGB PNG に，クラスごとに色の異なる楕円（舌の代わり）を描いたもの．
+
+使い方:
+    uv run python scripts/make_synthetic_dataset.py --out data/synthetic --per-dir 10 --seed 0
+"""
+
+from __future__ import annotations
+
+import argparse
+import logging
+import shutil
+import sys
+from pathlib import Path
+
+import numpy as np
+from PIL import Image, ImageDraw
+
+from tias_judge_model.data.classes import ALL_DIR_NAMES, parse_dir_name
+from tias_judge_model.data.manifest import build_manifest_records, write_manifest
+
+logger = logging.getLogger(__name__)
+
+# 出力先がこのスクリプトの生成物であることを示す目印．
+# --overwrite で消してよいのは目印のあるディレクトリだけにし，実データを誤って消さないようにする．
+MARKER_FILE = ".synthetic_dataset"
+
+# クラスごとの基準色（RGB）．学習 smoke テストで学習可能なよう，互いに十分離しておく．
+BASE_COLORS: dict[str, tuple[int, int, int]] = {
+    "pale": (235, 205, 200),
+    "light_red": (225, 140, 140),
+    "red": (215, 40, 45),
+    "dark_red": (120, 20, 30),
+    "purple": (110, 50, 140),
+}
+
+# mild は strong より「正常（淡紅）」寄りの薄い色にする（境界例を模すため）．
+MILD_BLEND_TO_NORMAL = 0.25
+
+MIN_SIZE = 96
+MAX_SIZE = 192
+COLOR_JITTER = 8
+PIXEL_NOISE_STD = 4.0
+
+
+def _class_color(label: str, severity: str) -> np.ndarray:
+    base = np.array(BASE_COLORS[label], dtype=np.float64)
+    if severity == "mild":
+        normal = np.array(BASE_COLORS["light_red"], dtype=np.float64)
+        base = (1.0 - MILD_BLEND_TO_NORMAL) * base + MILD_BLEND_TO_NORMAL * normal
+    return base
+
+
+def make_image(color: np.ndarray, rng: np.random.Generator) -> Image.Image:
+    """黒背景に楕円を描いた RGB 画像を 1 枚作る.
+
+    Args:
+        color: 楕円の基準色（`(3,)`, float64, 値域 0〜255）．
+        rng: 乱数生成器．
+
+    Returns:
+        RGB 画像（サイズは `MIN_SIZE`〜`MAX_SIZE` の範囲でランダム）．
+    """
+    width = int(rng.integers(MIN_SIZE, MAX_SIZE + 1))
+    height = int(rng.integers(MIN_SIZE, MAX_SIZE + 1))
+    margin_x = int(rng.integers(0, width // 10 + 1))
+    margin_y = int(rng.integers(0, height // 10 + 1))
+
+    mask_img = Image.new("L", (width, height), 0)
+    ImageDraw.Draw(mask_img).ellipse(
+        (margin_x, margin_y, width - 1 - margin_x, height - 1 - margin_y), fill=255
+    )
+    mask = np.asarray(mask_img) > 0  # (H, W), bool
+
+    jittered = color + rng.integers(-COLOR_JITTER, COLOR_JITTER + 1, size=3)
+    noise = rng.normal(0.0, PIXEL_NOISE_STD, size=(height, width, 3))
+    tongue = np.clip(jittered + noise, 1, 255)  # 舌領域が背景の黒 (0,0,0) と紛れないよう 1 以上
+    pixels = np.zeros((height, width, 3), dtype=np.uint8)  # (H, W, 3)
+    pixels[mask] = tongue[mask].astype(np.uint8)
+    return Image.fromarray(pixels)
+
+
+def generate(out_dir: Path, per_dir: int, seed: int) -> int:
+    """合成データセットを生成する.
+
+    Args:
+        out_dir: 出力先（空または存在しないディレクトリ）．
+        per_dir: 1 ディレクトリあたりの枚数．
+        seed: 乱数 seed．
+
+    Returns:
+        生成した画像の枚数．
+    """
+    rng = np.random.default_rng(seed)
+    images_dir = out_dir / "images"
+    out_dir.mkdir(parents=True, exist_ok=True)
+    (out_dir / MARKER_FILE).write_text(f"seed={seed}\nper_dir={per_dir}\n", encoding="utf-8")
+
+    serial = 0
+    for dir_name in ALL_DIR_NAMES:
+        label, severity = parse_dir_name(dir_name)
+        color = _class_color(label, severity)
+        class_dir = images_dir / dir_name
+        class_dir.mkdir(parents=True, exist_ok=True)
+        for _ in range(per_dir):
+            make_image(color, rng).save(class_dir / f"syn_{serial:06d}.png")
+            serial += 1
+        logger.info("%s/: %d 枚", dir_name, per_dir)
+
+    records = build_manifest_records(images_dir)
+    write_manifest(records, out_dir / "manifest.csv")
+    return serial
+
+
+def _prepare_out_dir(out_dir: Path, overwrite: bool) -> None:
+    if not out_dir.exists():
+        return
+    if not out_dir.is_dir():
+        raise ValueError(f"出力先がディレクトリではない: {out_dir}")
+    if not any(out_dir.iterdir()):
+        return
+    if not overwrite:
+        raise ValueError(f"出力先が空でない: {out_dir}（作り直すには --overwrite を付ける）")
+    if not (out_dir / MARKER_FILE).is_file():
+        raise ValueError(
+            f"出力先に合成データの目印 {MARKER_FILE} が無いため削除しない: {out_dir}"
+            "（合成データ以外を誤って消さないため）"
+        )
+    logger.info("既存の合成データを削除する: %s", out_dir)
+    shutil.rmtree(out_dir)
+
+
+def _parse_args(argv: list[str] | None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="合成の舌画像データセットを生成する")
+    parser.add_argument(
+        "--out", type=Path, default=Path("data/synthetic"), help="出力先（既定: data/synthetic）"
+    )
+    parser.add_argument(
+        "--per-dir", type=int, default=10, help="1 ディレクトリあたりの枚数（既定: 10）"
+    )
+    parser.add_argument("--seed", type=int, default=0, help="乱数 seed（既定: 0）")
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="既存の合成データを削除して作り直す（目印ファイルのある出力先のみ）",
+    )
+    args = parser.parse_args(argv)
+    if args.per_dir < 1:
+        parser.error("--per-dir は 1 以上を指定する")
+    return args
+
+
+def main(argv: list[str] | None = None) -> int:
+    """エントリポイント.
+
+    Args:
+        argv: コマンドライン引数（None なら `sys.argv[1:]`）．
+
+    Returns:
+        終了コード（成功 0・入力の問題 1）．
+    """
+    logging.basicConfig(
+        level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s: %(message)s"
+    )
+    args = _parse_args(argv)
+    try:
+        _prepare_out_dir(args.out, args.overwrite)
+    except ValueError as e:
+        logger.error("%s", e)
+        return 1
+    count = generate(args.out, args.per_dir, args.seed)
+    logger.info("合成データを生成した: %d 枚 -> %s", count, args.out)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/src/tias_judge_model/data/__init__.py b/src/tias_judge_model/data/__init__.py
new file mode 100644
index 0000000..8369271
--- /dev/null
+++ b/src/tias_judge_model/data/__init__.py
@@ -0,0 +1 @@
+"""データ層: クラス定義・manifest の生成と読み込み・患者単位分割."""
diff --git a/src/tias_judge_model/data/classes.py b/src/tias_judge_model/data/classes.py
new file mode 100644
index 0000000..b13903a
--- /dev/null
+++ b/src/tias_judge_model/data/classes.py
@@ -0,0 +1,125 @@
+"""舌色クラスと程度（severity）の固定定義.
+
+整数 ID は混同行列の軸をぶらさないために固定しており，順序を変更してはならない
+（SPEC_01「クラス定義」）．
+"""
+
+from __future__ import annotations
+
+# ID 順に並べる．この並びがそのままクラス ID になる．
+CLASS_SLUGS: tuple[str, ...] = ("pale", "light_red", "red", "dark_red", "purple")
+
+CLASS_DISPLAY_NAMES: dict[str, str] = {
+    "pale": "淡白",
+    "light_red": "淡紅",
+    "red": "紅",
+    "dark_red": "暗赤紅",
+    "purple": "紫",
+}
+
+NUM_CLASSES: int = len(CLASS_SLUGS)
+
+SEVERITIES: tuple[str, ...] = ("strong", "mild", "normal")
+
+# 淡紅（正常）のみ程度の区分が無い（TEST_01「フォルダ構成とラベル対応」）．
+VALID_SEVERITIES: dict[str, tuple[str, ...]] = {
+    "pale": ("strong", "mild"),
+    "light_red": ("normal",),
+    "red": ("strong", "mild"),
+    "dark_red": ("strong", "mild"),
+    "purple": ("strong", "mild"),
+}
+
+_SLUG_TO_ID: dict[str, int] = {slug: i for i, slug in enumerate(CLASS_SLUGS)}
+
+
+def label_to_id(label: str) -> int:
+    """クラス slug を整数 ID に変換する.
+
+    Args:
+        label: クラス slug（例: `"dark_red"`）．
+
+    Returns:
+        クラス ID（0〜4）．
+
+    Raises:
+        ValueError: 未知の slug の場合．
+    """
+    if label not in _SLUG_TO_ID:
+        raise ValueError(f"未知のクラス slug である: {label!r}（有効値: {', '.join(CLASS_SLUGS)}）")
+    return _SLUG_TO_ID[label]
+
+
+def id_to_label(class_id: int) -> str:
+    """整数 ID をクラス slug に変換する.
+
+    Args:
+        class_id: クラス ID（0〜4）．
+
+    Returns:
+        クラス slug．
+
+    Raises:
+        ValueError: 範囲外の ID の場合．
+    """
+    if not 0 <= class_id < NUM_CLASSES:
+        raise ValueError(f"クラス ID が範囲外である: {class_id}（0〜{NUM_CLASSES - 1}）")
+    return CLASS_SLUGS[class_id]
+
+
+def is_valid_combination(label: str, severity: str) -> bool:
+    """クラスと程度の組み合わせが有効かを返す.
+
+    Args:
+        label: クラス slug．
+        severity: 程度（`strong` / `mild` / `normal`）．
+
+    Returns:
+        有効な組み合わせなら True．未知の値を含む場合も False．
+    """
+    return severity in VALID_SEVERITIES.get(label, ())
+
+
+def make_dir_name(label: str, severity: str) -> str:
+    """クラスと程度から画像ディレクトリ名 `<label>_<severity>` を作る.
+
+    Args:
+        label: クラス slug．
+        severity: 程度．
+
+    Returns:
+        ディレクトリ名（例: `"light_red_normal"`）．
+
+    Raises:
+        ValueError: 無効な組み合わせの場合．
+    """
+    if not is_valid_combination(label, severity):
+        raise ValueError(f"無効なクラスと程度の組み合わせである: {label!r}, {severity!r}")
+    return f"{label}_{severity}"
+
+
+def parse_dir_name(name: str) -> tuple[str, str]:
+    """画像ディレクトリ名 `<label>_<severity>` を (label, severity) に解釈する.
+
+    `light_red_normal` のように label 自体が `_` を含むため，末尾の `_` で区切る．
+
+    Args:
+        name: ディレクトリ名．
+
+    Returns:
+        (label, severity) のタプル．
+
+    Raises:
+        ValueError: 書式が不正，または無効な組み合わせの場合．
+    """
+    label, sep, severity = name.rpartition("_")
+    if not sep or not is_valid_combination(label, severity):
+        valid = ", ".join(ALL_DIR_NAMES)
+        raise ValueError(f"想定外の画像ディレクトリ名である: {name!r}（有効値: {valid}）")
+    return label, severity
+
+
+# 有効なディレクトリ名の一覧（クラス ID 順，程度は VALID_SEVERITIES の順）．
+ALL_DIR_NAMES: tuple[str, ...] = tuple(
+    make_dir_name(label, severity) for label in CLASS_SLUGS for severity in VALID_SEVERITIES[label]
+)
diff --git a/src/tias_judge_model/data/manifest.py b/src/tias_judge_model/data/manifest.py
new file mode 100644
index 0000000..e39157e
--- /dev/null
+++ b/src/tias_judge_model/data/manifest.py
@@ -0,0 +1,275 @@
+"""manifest（学習が読む唯一の入口）の生成・書き出し・読み込み・検証.
+
+manifest の列は SPEC_01「データ契約」に従う．
+例外メッセージ・ログには患者 ID・画像ファイル名を含めず，行番号・件数・クラス名で示す
+（CLAUDE.md 必須ルール）．
+"""
+
+from __future__ import annotations
+
+import csv
+import logging
+from collections import Counter
+from collections.abc import Iterable, Sequence
+from dataclasses import asdict, dataclass
+from pathlib import Path, PurePosixPath
+
+from tias_judge_model.data.classes import (
+    CLASS_SLUGS,
+    SEVERITIES,
+    is_valid_combination,
+    label_to_id,
+    parse_dir_name,
+)
+
+logger = logging.getLogger(__name__)
+
+MANIFEST_COLUMNS: tuple[str, ...] = ("image_path", "patient_id", "label", "severity", "note")
+REQUIRED_COLUMNS: tuple[str, ...] = ("image_path", "patient_id", "label", "severity")
+IMAGE_SUFFIX = ".png"
+
+# CSV ではヘッダが 1 行目なので，レコードの添字 0 は 2 行目になる．
+_FIRST_DATA_LINE = 2
+
+
+@dataclass(frozen=True)
+class ManifestRecord:
+    """manifest の 1 行.
+
+    Attributes:
+        image_path: `images/` からの相対パス（区切りは `/`）．
+        patient_id: 患者 ID．分割の単位．
+        label: クラス slug．
+        severity: 程度（`strong` / `mild` / `normal`）．
+        note: 任意の備考（除外理由等）．
+    """
+
+    image_path: str
+    patient_id: str
+    label: str
+    severity: str
+    note: str = ""
+
+    @property
+    def label_id(self) -> int:
+        """クラス ID（0〜4）."""
+        return label_to_id(self.label)
+
+
+def build_manifest_records(images_dir: Path) -> list[ManifestRecord]:
+    """`images/<label>_<severity>/*.png` を走査して manifest のレコードを作る.
+
+    `patient_id` はファイル名の stem とする（1 患者 1 枚が確定しているため．SPEC_01）．
+    この前提が崩れる兆候（同じ stem が複数ある）があれば自動では続行しない．
+
+    Args:
+        images_dir: 画像ディレクトリ（`<data_root>/images`）．
+
+    Returns:
+        検証済みのレコード（`image_path` 昇順）．
+
+    Raises:
+        ValueError: ディレクトリが無い・想定外のディレクトリ名やファイルがある・
+            画像が 0 枚のクラスディレクトリがある・画像が 1 枚も無い・stem が重複する・
+            レコードの検証に失敗した場合．
+    """
+    if not images_dir.is_dir():
+        raise ValueError(f"画像ディレクトリが存在しない: {images_dir}")
+
+    stray_files = [p for p in images_dir.iterdir() if not p.is_dir()]
+    if stray_files:
+        raise ValueError(
+            f"画像ディレクトリ直下にディレクトリ以外が {len(stray_files)} 件ある"
+            "（画像は <label>_<severity>/ の下に置く）"
+        )
+
+    records: list[ManifestRecord] = []
+    for class_dir in sorted(images_dir.iterdir(), key=lambda p: p.name):
+        label, severity = parse_dir_name(class_dir.name)
+        entries = list(class_dir.iterdir())
+        subdirs = [p for p in entries if p.is_dir()]
+        if subdirs:
+            raise ValueError(
+                f"{class_dir.name}/ にサブディレクトリが {len(subdirs)} 件ある（想定外の構成）"
+            )
+        non_png = [p for p in entries if p.suffix.lower() != IMAGE_SUFFIX]
+        if non_png:
+            suffixes = sorted({p.suffix or "(拡張子なし)" for p in non_png})
+            raise ValueError(
+                f"{class_dir.name}/ に PNG 以外のファイルが {len(non_png)} 件ある"
+                f"（拡張子: {', '.join(suffixes)}）"
+            )
+        pngs = sorted(entries, key=lambda p: p.name)
+        if not pngs:
+            # 空のまま続行すると，そのクラスが欠けた状態で学習・評価が進んでしまう．
+            raise ValueError(f"{class_dir.name}/ に画像が 1 枚も無い（空のクラスディレクトリ）")
+        for png in pngs:
+            records.append(
+                ManifestRecord(
+                    image_path=f"{class_dir.name}/{png.name}",
+                    patient_id=png.stem,
+                    label=label,
+                    severity=severity,
+                )
+            )
+        logger.info("%s/: %d 件", class_dir.name, len(pngs))
+
+    if not records:
+        raise ValueError("画像が 1 枚も見つからない")
+
+    stem_counts = Counter(r.patient_id for r in records)
+    duplicated = sum(1 for n in stem_counts.values() if n > 1)
+    if duplicated:
+        # stem を患者 ID と見なす前提（1 患者 1 枚）が崩れている可能性があるため止める．
+        raise ValueError(
+            f"ファイル名（stem）が重複する画像が {duplicated} 種類ある．"
+            "stem を patient_id と見なせないため，実際の患者 ID を確認すること"
+        )
+
+    records.sort(key=lambda r: r.image_path)
+    validate_records(records)
+    logger.info("manifest のレコードを %d 件生成した", len(records))
+    return records
+
+
+def write_manifest(records: Iterable[ManifestRecord], path: Path) -> None:
+    """manifest を UTF-8 の CSV として書き出す.
+
+    Args:
+        records: 書き出すレコード．
+        path: 出力先の CSV パス．親ディレクトリは作成される．
+    """
+    path.parent.mkdir(parents=True, exist_ok=True)
+    count = 0
+    with path.open("w", encoding="utf-8", newline="") as f:
+        writer = csv.DictWriter(f, fieldnames=MANIFEST_COLUMNS)
+        writer.writeheader()
+        for r in records:
+            writer.writerow(asdict(r))
+            count += 1
+    logger.info("manifest を書き出した（%d 件）", count)
+
+
+def read_manifest(path: Path) -> list[ManifestRecord]:
+    """manifest CSV を読み込み，検証済みのレコードを返す.
+
+    `note` 列は省略可（無ければ空文字とする）．それ以外の列は必須．
+
+    Args:
+        path: manifest CSV のパス．
+
+    Returns:
+        検証済みのレコード（ファイル内の順序のまま）．
+
+    Raises:
+        ValueError: ファイルが無い・必須列の欠落・列数の不一致・レコードの検証に失敗した場合．
+    """
+    if not path.is_file():
+        raise ValueError(f"manifest が存在しない: {path}")
+
+    # BOM 付きで保存された場合（Excel 等）もヘッダを正しく読むため utf-8-sig を使う．
+    with path.open(encoding="utf-8-sig", newline="") as f:
+        reader = csv.DictReader(f)
+        header = reader.fieldnames or []
+        missing = [c for c in REQUIRED_COLUMNS if c not in header]
+        if missing:
+            raise ValueError(f"manifest に必須列が無い: {', '.join(missing)}")
+
+        records: list[ManifestRecord] = []
+        for line_number, row in enumerate(reader, start=_FIRST_DATA_LINE):
+            if None in row:
+                raise ValueError(f"manifest の {line_number} 行目: 列数がヘッダより多い")
+            if any(row.get(c) is None for c in REQUIRED_COLUMNS):
+                raise ValueError(f"manifest の {line_number} 行目: 列数がヘッダより少ない")
+            records.append(
+                ManifestRecord(
+                    image_path=row["image_path"],
+                    patient_id=row["patient_id"],
+                    label=row["label"],
+                    severity=row["severity"],
+                    note=row.get("note") or "",
+                )
+            )
+
+    if not records:
+        raise ValueError("manifest にデータ行が 1 行も無い")
+    validate_records(records)
+    logger.info(
+        "manifest を読み込んだ（%d 件・患者 %d 人）", len(records), _count_patients(records)
+    )
+    return records
+
+
+def validate_records(records: Sequence[ManifestRecord]) -> None:
+    """manifest レコードの整合性を検証する.
+
+    エラー位置は CSV の行番号（ヘッダを 1 行目とし，レコードの添字 0 を 2 行目とする）で示す．
+
+    Args:
+        records: 検証するレコード．
+
+    Raises:
+        ValueError: `image_path` が空・不正な形式・重複，`patient_id` が空，
+            未知の label / severity，無効な組み合わせ，同一患者に異なる label がある場合．
+    """
+    seen_paths: dict[str, int] = {}
+    patient_labels: dict[str, tuple[str, int]] = {}
+    for index, r in enumerate(records):
+        line = index + _FIRST_DATA_LINE
+        where = f"manifest の {line} 行目"
+
+        if not r.image_path.strip():
+            raise ValueError(f"{where}: image_path が空である")
+        _check_image_path_format(r.image_path, where)
+        if r.image_path in seen_paths:
+            raise ValueError(
+                f"{where}: image_path が {seen_paths[r.image_path]} 行目と重複している"
+            )
+        seen_paths[r.image_path] = line
+
+        if not r.patient_id.strip():
+            raise ValueError(f"{where}: patient_id が空である")
+        if r.label not in CLASS_SLUGS:
+            raise ValueError(f"{where}: 未知の label である: {r.label!r}")
+        if r.severity not in SEVERITIES:
+            raise ValueError(f"{where}: 未知の severity である: {r.severity!r}")
+        if not is_valid_combination(r.label, r.severity):
+            raise ValueError(
+                f"{where}: label と severity の組み合わせが無効である: {r.label}, {r.severity}"
+            )
+
+        previous = patient_labels.get(r.patient_id)
+        if previous is None:
+            patient_labels[r.patient_id] = (r.label, line)
+        elif previous[0] != r.label:
+            # 同一患者に異なる label があると，患者単位の層化分割が成り立たない．
+            raise ValueError(
+                f"{where}: 同一患者に異なる label が付いている"
+                f"（{previous[1]} 行目は {previous[0]}，この行は {r.label}）"
+            )
+
+
+def resolve_image_path(images_dir: Path, record: ManifestRecord) -> Path:
+    """レコードの画像の実パスを返す.
+
+    Args:
+        images_dir: 画像ディレクトリ（`<data_root>/images`）．
+        record: manifest レコード．
+
+    Returns:
+        画像ファイルのパス．
+    """
+    return images_dir.joinpath(*PurePosixPath(record.image_path).parts)
+
+
+def _check_image_path_format(image_path: str, where: str) -> None:
+    # images/ の外を指すパスや OS 依存の区切りは，サーバと手元で解釈が変わるため拒否する．
+    if "\\" in image_path:
+        raise ValueError(f"{where}: image_path の区切りは '/' でなければならない")
+    pure = PurePosixPath(image_path)
+    if pure.is_absolute() or ".." in pure.parts or ":" in image_path:
+        raise ValueError(f"{where}: image_path は images/ からの相対パスでなければならない")
+
+
+def _count_patients(records: Sequence[ManifestRecord]) -> int:
+    return len({r.patient_id for r in records})
diff --git a/src/tias_judge_model/data/split.py b/src/tias_judge_model/data/split.py
new file mode 100644
index 0000000..d803891
--- /dev/null
+++ b/src/tias_judge_model/data/split.py
@@ -0,0 +1,264 @@
+"""患者単位の分割（単一分割・K-fold 交差検証）と分割後の集計.
+
+分割は常に `patient_id` 単位で行い，同一患者が複数の分割に跨らないようにする（SPEC_02）．
+1 患者は 1 つの label しか持たない（manifest の検証で保証）ため，患者の一覧を label で
+層化して分割すれば「患者単位」と「クラス層化」を同時に満たせる．
+"""
+
+from __future__ import annotations
+
+import logging
+import math
+from collections import Counter
+from collections.abc import Collection, Iterable, Sequence
+from dataclasses import dataclass
+
+import numpy as np
+from sklearn.model_selection import StratifiedKFold
+
+from tias_judge_model.data.classes import CLASS_SLUGS
+from tias_judge_model.data.manifest import ManifestRecord
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class SplitResult:
+    """単一分割（train / val / test）の結果.
+
+    各フィールドは患者 ID の昇順タプル．`runs/` への保存はサーバ上でのみ行うこと
+    （患者 ID を含むため回収対象外．SPEC_01「回収ホワイトリスト」）．
+
+    Attributes:
+        train: train に属する患者 ID．
+        val: val に属する患者 ID．
+        test: test に属する患者 ID．
+    """
+
+    train: tuple[str, ...]
+    val: tuple[str, ...]
+    test: tuple[str, ...]
+
+    def to_dict(self) -> dict[str, list[str]]:
+        """保存用に `{"train": [...], "val": [...], "test": [...]}` を返す."""
+        return {"train": list(self.train), "val": list(self.val), "test": list(self.test)}
+
+
+@dataclass(frozen=True)
+class Fold:
+    """K-fold 交差検証の 1 fold.
+
+    Attributes:
+        index: fold 番号（0 始まり）．
+        train: 学習に使う患者 ID（昇順）．
+        held_out: この fold で評価に使う患者 ID（昇順）．
+    """
+
+    index: int
+    train: tuple[str, ...]
+    held_out: tuple[str, ...]
+
+    def to_dict(self) -> dict[str, int | list[str]]:
+        """保存用に `{"index": i, "train": [...], "held_out": [...]}` を返す."""
+        return {"index": self.index, "train": list(self.train), "held_out": list(self.held_out)}
+
+
+def patient_labels(records: Iterable[ManifestRecord]) -> dict[str, str]:
+    """患者 ID → label の対応を作る.
+
+    Args:
+        records: manifest レコード．
+
+    Returns:
+        患者 ID をキー，label を値とする辞書．
+
+    Raises:
+        ValueError: 同一患者に異なる label が付いている場合．
+    """
+    mapping: dict[str, str] = {}
+    for r in records:
+        existing = mapping.setdefault(r.patient_id, r.label)
+        if existing != r.label:
+            raise ValueError("同一患者に異なる label が付いている（manifest の検証を通すこと）")
+    return mapping
+
+
+def split_train_val_test(
+    records: Sequence[ManifestRecord], val_ratio: float, test_ratio: float, seed: int
+) -> SplitResult:
+    """患者単位・クラス層化で train / val / test に分割する.
+
+    クラスごとに患者 ID を昇順に並べてから seed で並べ替え，先頭から test・val を
+    `round(患者数 × 比率)` 人ずつ取り，残りを train とする．同じ入力と seed なら
+    入力レコードの順序によらず同じ結果になる．
+
+    Args:
+        records: manifest レコード（検証済み）．
+        val_ratio: val の比率（0 より大きく 1 未満）．
+        test_ratio: test の比率（0 より大きく 1 未満）．
+        seed: 乱数 seed．
+
+    Returns:
+        分割結果．
+
+    Raises:
+        ValueError: 比率が不正，レコードが空，同一患者に異なる label がある，
+            またはあるクラスで 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)
+    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)
+        if not patients:
+            continue
+        shuffled = [patients[i] for i in rng.permutation(len(patients))]
+        n_test = _round_half_up(len(patients) * test_ratio)
+        n_val = _round_half_up(len(patients) * val_ratio)
+        if n_test + n_val >= len(patients):
+            raise ValueError(
+                f"クラス {label} の患者 {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,
+                len(patients),
+                n_val,
+                n_test,
+            )
+        test.extend(shuffled[:n_test])
+        val.extend(shuffled[n_test : n_test + n_val])
+        train.extend(shuffled[n_test + n_val :])
+
+    result = SplitResult(
+        train=tuple(sorted(train)), val=tuple(sorted(val)), test=tuple(sorted(test))
+    )
+    logger.info(
+        "単一分割（seed=%d）: 患者 train %d・val %d・test %d",
+        seed,
+        len(result.train),
+        len(result.val),
+        len(result.test),
+    )
+    return result
+
+
+def make_kfold_splits(records: Sequence[ManifestRecord], n_folds: int, seed: int) -> list[Fold]:
+    """患者単位・クラス層化の K-fold 交差検証の分割を作る.
+
+    患者の一覧（患者 ID 昇順）を label で層化して `StratifiedKFold` にかける．
+    各患者はちょうど 1 つの fold の `held_out` に入る．
+
+    Args:
+        records: manifest レコード（検証済み）．
+        n_folds: fold 数（2 以上）．
+        seed: 乱数 seed．
+
+    Returns:
+        fold のリスト（長さ `n_folds`）．
+
+    Raises:
+        ValueError: fold 数が不正，レコードが空，同一患者に異なる label がある，
+            またはあるクラスの患者数が 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 ができ評価が歪むため止める．
+        if len(patients) < n_folds:
+            raise ValueError(
+                f"クラス {label} の患者数 {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])
+    splitter = StratifiedKFold(n_splits=n_folds, shuffle=True, random_state=seed)
+
+    folds: list[Fold] = []
+    for index, (train_idx, held_idx) in enumerate(splitter.split(np.zeros(len(y)), y)):
+        folds.append(
+            Fold(
+                index=index,
+                train=tuple(sorted(patient_ids[i] for i in train_idx)),
+                held_out=tuple(sorted(patient_ids[i] for i in held_idx)),
+            )
+        )
+    logger.info(
+        "%d-fold 分割（seed=%d）: held_out の患者数 %s",
+        n_folds,
+        seed,
+        [len(f.held_out) for f in folds],
+    )
+    return folds
+
+
+def select_records(
+    records: Iterable[ManifestRecord], patient_ids: Collection[str]
+) -> list[ManifestRecord]:
+    """指定した患者のレコードだけを取り出す（入力の順序を保つ）.
+
+    Args:
+        records: manifest レコード．
+        patient_ids: 取り出す患者 ID．
+
+    Returns:
+        該当するレコード．
+    """
+    wanted = set(patient_ids)
+    return [r for r in records if r.patient_id in wanted]
+
+
+def count_by_class(records: Iterable[ManifestRecord]) -> dict[str, int]:
+    """クラスごとの画像枚数を数える.
+
+    Args:
+        records: manifest レコード．
+
+    Returns:
+        クラス slug → 枚数（全クラスをクラス ID 順に含み，無いクラスは 0）．
+    """
+    counts = Counter(r.label for r in records)
+    return {label: counts.get(label, 0) for label in CLASS_SLUGS}
+
+
+def count_by_class_severity(records: Iterable[ManifestRecord]) -> dict[tuple[str, str], int]:
+    """(クラス, 程度) ごとの画像枚数を数える（分割後の severity の偏り確認用）.
+
+    Args:
+        records: manifest レコード．
+
+    Returns:
+        (label, severity) → 枚数（出現した組み合わせのみ．クラス ID 順・程度名順）．
+    """
+    counts = Counter((r.label, r.severity) for r in records)
+    order = {label: i for i, label in enumerate(CLASS_SLUGS)}
+    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]]:
+    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)
+    # 入力順に依存させず決定的にするため，患者 ID でソートしておく．
+    return {label: sorted(patients) for label, patients in by_class.items()}
+
+
+def _round_half_up(value: float) -> int:
+    # 組み込み round は偶数丸めで直感に反するため四捨五入を使う．
+    return math.floor(value + 0.5)
diff --git a/src/tias_judge_model/schema.py b/src/tias_judge_model/schema.py
new file mode 100644
index 0000000..d5a85fb
--- /dev/null
+++ b/src/tias_judge_model/schema.py
@@ -0,0 +1,123 @@
+"""pydantic による設定スキーマと設定 YAML の読み込み.
+
+学習・モデル関連の設定は後続のステップで `ExperimentConfig` にフィールドを追加して拡張する．
+"""
+
+from __future__ import annotations
+
+import os
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Any
+
+import yaml
+from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
+
+# データのルートを上書きする環境変数．サーバと手元で YAML を書き換えずに済ませるため．
+DATA_ROOT_ENV_VAR = "TIAS_DATA_ROOT"
+
+
+class _StrictModel(BaseModel):
+    """未知のキー（綴り間違い）を拒否し，生成後の変更を禁止する基底モデル."""
+
+    model_config = ConfigDict(extra="forbid", frozen=True)
+
+
+class DataConfig(_StrictModel):
+    """データの場所に関する設定.
+
+    Attributes:
+        root: データのルートディレクトリ（`images/` と manifest を含む）．`~` は展開される．
+            相対パスはカレントディレクトリ基準で解釈する．
+        manifest: manifest CSV のパス．相対パスは `root` からの相対として解釈する．
+    """
+
+    root: Path
+    manifest: Path = Path("manifest.csv")
+
+    @field_validator("root", "manifest", mode="after")
+    @classmethod
+    def _expand_user(cls, value: Path) -> Path:
+        return value.expanduser()
+
+    @property
+    def images_dir(self) -> Path:
+        """画像ディレクトリ（`<root>/images`）."""
+        return self.root / "images"
+
+    @property
+    def manifest_path(self) -> Path:
+        """manifest CSV の解決済みパス."""
+        return self.manifest if self.manifest.is_absolute() else self.root / self.manifest
+
+
+class SplitConfig(_StrictModel):
+    """患者単位分割の設定.
+
+    Attributes:
+        seed: 分割の乱数 seed．
+        val_ratio: 単一分割で val に回す患者の比率．
+        test_ratio: 単一分割で test に回す患者の比率．
+        n_folds: 交差検証の fold 数．
+    """
+
+    seed: int = 42
+    val_ratio: float = Field(default=0.15, gt=0.0, lt=1.0)
+    test_ratio: float = Field(default=0.15, gt=0.0, lt=1.0)
+    n_folds: int = Field(default=5, ge=2)
+
+    @model_validator(mode="after")
+    def _check_ratio_sum(self) -> SplitConfig:
+        # train が残らない比率は分割として成立しないため拒否する．
+        if self.val_ratio + self.test_ratio >= 1.0:
+            raise ValueError(
+                "val_ratio と test_ratio の合計は 1 未満でなければならない"
+                f"（現在 {self.val_ratio} + {self.test_ratio}）"
+            )
+        return self
+
+
+class ExperimentConfig(_StrictModel):
+    """実験設定のルート.
+
+    Attributes:
+        data: データの場所．
+        split: 分割の設定．
+    """
+
+    data: DataConfig
+    split: SplitConfig = Field(default_factory=SplitConfig)
+
+
+def load_config(path: Path, environ: Mapping[str, str] | None = None) -> ExperimentConfig:
+    """設定 YAML を読み込み，検証済みの設定を返す.
+
+    環境変数 `TIAS_DATA_ROOT` が空でない値で設定されていれば，YAML の `data.root` より優先する．
+
+    Args:
+        path: 設定 YAML のパス．
+        environ: 参照する環境変数．None なら `os.environ` を使う．
+
+    Returns:
+        検証済みの設定．
+
+    Raises:
+        ValueError: YAML のトップレベルがマッピングでない場合．
+        pydantic.ValidationError: 設定値が不正な場合．
+    """
+    env = os.environ if environ is None else environ
+    with path.open(encoding="utf-8") as f:
+        raw: Any = yaml.safe_load(f)
+    if raw is None:
+        raw = {}
+    if not isinstance(raw, dict):
+        raise ValueError(f"設定 YAML のトップレベルはマッピングでなければならない: {path}")
+
+    env_root = env.get(DATA_ROOT_ENV_VAR, "")
+    if env_root:
+        data = raw.get("data") or {}
+        if not isinstance(data, dict):
+            raise ValueError(f"設定 YAML の data はマッピングでなければならない: {path}")
+        raw = {**raw, "data": {**data, "root": env_root}}
+
+    return ExperimentConfig.model_validate(raw)
diff --git a/tests/data/test_classes.py b/tests/data/test_classes.py
new file mode 100644
index 0000000..06b7cf7
--- /dev/null
+++ b/tests/data/test_classes.py
@@ -0,0 +1,117 @@
+"""クラス定義のテスト（SPEC_01「クラス定義」・TEST_01「フォルダ構成とラベル対応」）."""
+
+import pytest
+
+from tias_judge_model.data.classes import (
+    ALL_DIR_NAMES,
+    CLASS_DISPLAY_NAMES,
+    CLASS_SLUGS,
+    NUM_CLASSES,
+    id_to_label,
+    is_valid_combination,
+    label_to_id,
+    make_dir_name,
+    parse_dir_name,
+)
+
+# SPEC_01 の固定表（ID・slug・表示名）
+SPEC_CLASSES = [
+    (0, "pale", "淡白"),
+    (1, "light_red", "淡紅"),
+    (2, "red", "紅"),
+    (3, "dark_red", "暗赤紅"),
+    (4, "purple", "紫"),
+]
+
+# TEST_01 の対応表（ディレクトリ名は SPEC_01 の `<label>_<severity>` スラッグ）
+SPEC_DIRS = {
+    "light_red_normal": ("light_red", "normal"),
+    "dark_red_strong": ("dark_red", "strong"),
+    "dark_red_mild": ("dark_red", "mild"),
+    "purple_mild": ("purple", "mild"),
+    "red_strong": ("red", "strong"),
+    "red_mild": ("red", "mild"),
+    "purple_strong": ("purple", "strong"),
+    "pale_strong": ("pale", "strong"),
+    "pale_mild": ("pale", "mild"),
+}
+
+
+def test_class_ids_follow_fixed_spec_order() -> None:
+    assert CLASS_SLUGS == tuple(slug for _, slug, _ in SPEC_CLASSES)
+    assert NUM_CLASSES == 5
+
+
+@pytest.mark.parametrize(("class_id", "slug", "display"), SPEC_CLASSES)
+def test_label_id_mapping_matches_spec(class_id: int, slug: str, display: str) -> None:
+    assert label_to_id(slug) == class_id
+    assert id_to_label(class_id) == slug
+    assert CLASS_DISPLAY_NAMES[slug] == display
+
+
+@pytest.mark.parametrize("label", ["", "Pale", "orange", "淡白", "light-red"])
+def test_label_to_id_rejects_unknown_label(label: str) -> None:
+    with pytest.raises(ValueError):
+        label_to_id(label)
+
+
+@pytest.mark.parametrize("class_id", [-1, 5, 100])
+def test_id_to_label_rejects_out_of_range(class_id: int) -> None:
+    with pytest.raises(ValueError):
+        id_to_label(class_id)
+
+
+def test_all_dir_names_are_exactly_the_nine_spec_dirs() -> None:
+    assert len(ALL_DIR_NAMES) == 9
+    assert set(ALL_DIR_NAMES) == set(SPEC_DIRS)
+
+
+@pytest.mark.parametrize(("name", "expected"), sorted(SPEC_DIRS.items()))
+def test_parse_dir_name_follows_test01_table(name: str, expected: tuple[str, str]) -> None:
+    assert parse_dir_name(name) == expected
+
+
+@pytest.mark.parametrize(("name", "expected"), sorted(SPEC_DIRS.items()))
+def test_make_dir_name_is_inverse_of_parse(name: str, expected: tuple[str, str]) -> None:
+    assert make_dir_name(*expected) == name
+
+
+@pytest.mark.parametrize(
+    "name",
+    [
+        "light_red_strong",  # 淡紅は normal のみ
+        "light_red_mild",
+        "pale_normal",  # normal は淡紅のみ
+        "dark_red_normal",
+        "red",
+        "light_red",
+        "",
+        "_",
+        "orange_strong",
+        "red_Strong",
+        "purple_mild_extra",
+        "淡紅（正常）",  # 日本語のフォルダ名はスラッグ化してから置く
+        "暗赤紅＿あり",
+    ],
+)
+def test_parse_dir_name_rejects_invalid_name(name: str) -> None:
+    with pytest.raises(ValueError):
+        parse_dir_name(name)
+
+
+@pytest.mark.parametrize(
+    ("label", "severity"),
+    [("light_red", "strong"), ("pale", "normal"), ("orange", "mild"), ("red", "weak")],
+)
+def test_make_dir_name_rejects_invalid_combination(label: str, severity: str) -> None:
+    with pytest.raises(ValueError):
+        make_dir_name(label, severity)
+
+
+def test_is_valid_combination_matches_test01_table() -> None:
+    valid = set(SPEC_DIRS.values())
+    for label in CLASS_SLUGS:
+        for severity in ("strong", "mild", "normal"):
+            assert is_valid_combination(label, severity) == ((label, severity) in valid)
+    assert not is_valid_combination("orange", "strong")
+    assert not is_valid_combination("red", "weak")
diff --git a/tests/data/test_manifest.py b/tests/data/test_manifest.py
new file mode 100644
index 0000000..fe818d6
--- /dev/null
+++ b/tests/data/test_manifest.py
@@ -0,0 +1,403 @@
+"""manifest の生成・読み書き・検証のテスト.
+
+仕様: SPEC_01「データ契約」・TEST_01「フォルダ構成とラベル対応」・error-handling ルール
+（fail fast・例外メッセージに患者 ID / ファイル名を含めない）．
+"""
+
+import csv
+import logging
+from pathlib import Path
+
+import pytest
+from PIL import Image
+
+from tias_judge_model.data.manifest import (
+    ManifestRecord,
+    build_manifest_records,
+    read_manifest,
+    resolve_image_path,
+    validate_records,
+    write_manifest,
+)
+
+# 例外メッセージ・ログに出てはならない識別子（患者 ID・ファイル名を模した値）
+SECRET_PATIENT = "SECRETPATIENT0001"
+SECRET_FILE_STEM = "SECRETFILE0001"
+
+TEST01_TABLE = {
+    "light_red_normal": ("light_red", "normal"),
+    "dark_red_strong": ("dark_red", "strong"),
+    "dark_red_mild": ("dark_red", "mild"),
+    "purple_mild": ("purple", "mild"),
+    "red_strong": ("red", "strong"),
+    "red_mild": ("red", "mild"),
+    "purple_strong": ("purple", "strong"),
+    "pale_strong": ("pale", "strong"),
+    "pale_mild": ("pale", "mild"),
+}
+
+
+def _rec(
+    image_path: str = "red_strong/a.png",
+    patient_id: str = "p001",
+    label: str = "red",
+    severity: str = "strong",
+    note: str = "",
+) -> ManifestRecord:
+    return ManifestRecord(
+        image_path=image_path, patient_id=patient_id, label=label, severity=severity, note=note
+    )
+
+
+def _save_png(path: Path) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    Image.new("RGB", (4, 4), (0, 0, 0)).save(path)
+
+
+def _write_csv(path: Path, header: list[str], rows: list[list[str]]) -> None:
+    with path.open("w", encoding="utf-8", newline="") as f:
+        writer = csv.writer(f)
+        writer.writerow(header)
+        writer.writerows(rows)
+
+
+def _assert_no_pii(message: str, *secrets: str) -> None:
+    for secret in secrets:
+        assert secret not in message
+
+
+# --- validate_records ---------------------------------------------------------------------
+
+
+def test_validate_accepts_valid_records() -> None:
+    validate_records(
+        [
+            _rec("light_red_normal/a.png", "p1", "light_red", "normal"),
+            _rec("pale_mild/b.png", "p2", "pale", "mild"),
+            _rec("purple_strong/c.png", "p3", "purple", "strong"),
+        ]
+    )
+
+
+def test_validate_accepts_multiple_images_of_same_patient_with_same_label() -> None:
+    # 将来 1 患者複数枚になっても，label が一致していれば有効（SPEC_01）
+    validate_records(
+        [
+            _rec("red_strong/a.png", "p1", "red", "strong"),
+            _rec("red_mild/b.png", "p1", "red", "mild"),
+        ]
+    )
+
+
+@pytest.mark.parametrize("patient_id", ["", "   "])
+def test_validate_rejects_missing_patient_id(patient_id: str) -> None:
+    with pytest.raises(ValueError):
+        validate_records([_rec(patient_id="p0"), _rec("red_strong/b.png", patient_id=patient_id)])
+
+
+@pytest.mark.parametrize("label", ["orange", "Red", "", "紅"])
+def test_validate_rejects_unknown_label(label: str) -> None:
+    with pytest.raises(ValueError):
+        validate_records([_rec(label=label)])
+
+
+@pytest.mark.parametrize("severity", ["weak", "Strong", "", "あり"])
+def test_validate_rejects_unknown_severity(severity: str) -> None:
+    with pytest.raises(ValueError):
+        validate_records([_rec(severity=severity)])
+
+
+@pytest.mark.parametrize(
+    ("label", "severity"),
+    [
+        ("light_red", "strong"),
+        ("light_red", "mild"),
+        ("pale", "normal"),
+        ("red", "normal"),
+        ("dark_red", "normal"),
+        ("purple", "normal"),
+    ],
+)
+def test_validate_rejects_invalid_label_severity_combination(label: str, severity: str) -> None:
+    with pytest.raises(ValueError):
+        validate_records([_rec(label=label, severity=severity)])
+
+
+def test_validate_rejects_duplicate_image_path() -> None:
+    records = [_rec("red_strong/a.png", "p1"), _rec("red_strong/a.png", "p2")]
+    with pytest.raises(ValueError):
+        validate_records(records)
+
+
+def test_validate_rejects_same_patient_with_different_labels() -> None:
+    records = [
+        _rec("red_strong/a.png", "p1", "red", "strong"),
+        _rec("purple_strong/b.png", "p1", "purple", "strong"),
+    ]
+    with pytest.raises(ValueError):
+        validate_records(records)
+
+
+@pytest.mark.parametrize("image_path", ["", "/abs/red_strong/a.png", "../outside/a.png"])
+def test_validate_rejects_image_path_not_relative_to_images(image_path: str) -> None:
+    with pytest.raises(ValueError):
+        validate_records([_rec(image_path=image_path)])
+
+
+# --- 例外メッセージに個人情報を出さない ----------------------------------------------------------
+
+
+def _pii_cases() -> list[tuple[str, list[ManifestRecord]]]:
+    path = f"red_strong/{SECRET_FILE_STEM}.png"
+    return [
+        ("duplicate_image_path", [_rec(path, "pA"), _rec(path, SECRET_PATIENT)]),
+        (
+            "conflicting_labels",
+            [
+                _rec(path, SECRET_PATIENT, "red", "strong"),
+                _rec(f"purple_mild/{SECRET_FILE_STEM}x.png", SECRET_PATIENT, "purple", "mild"),
+            ],
+        ),
+        ("unknown_label", [_rec(path, SECRET_PATIENT, "orange", "strong")]),
+        ("unknown_severity", [_rec(path, SECRET_PATIENT, "red", "weak")]),
+        ("invalid_combination", [_rec(path, SECRET_PATIENT, "light_red", "strong")]),
+        ("empty_patient_id", [_rec(path, "")]),
+        ("absolute_path", [_rec(f"/{path}", SECRET_PATIENT)]),
+    ]
+
+
+@pytest.mark.parametrize(("case", "records"), _pii_cases(), ids=[c for c, _ in _pii_cases()])
+def test_validation_error_message_has_no_patient_id_or_file_name(
+    case: str, records: list[ManifestRecord]
+) -> None:
+    with pytest.raises(ValueError) as exc_info:
+        validate_records(records)
+    _assert_no_pii(str(exc_info.value), SECRET_PATIENT, SECRET_FILE_STEM)
+
+
+def test_validation_error_message_points_to_line_number() -> None:
+    records = [_rec("red_strong/a.png", "p1"), _rec("red_strong/b.png", "")]
+    with pytest.raises(ValueError, match="3"):
+        validate_records(records)
+
+
+# --- write_manifest / read_manifest -----------------------------------------------------------
+
+
+def test_write_then_read_roundtrip(tmp_path: Path) -> None:
+    records = [
+        _rec("light_red_normal/a.png", "p1", "light_red", "normal"),
+        _rec("dark_red_mild/b.png", "p2", "dark_red", "mild", note="除外候補"),
+    ]
+    path = tmp_path / "sub" / "manifest.csv"
+    write_manifest(records, path)
+    assert read_manifest(path) == records
+
+
+def test_written_manifest_has_spec_columns(tmp_path: Path) -> None:
+    path = tmp_path / "manifest.csv"
+    write_manifest([_rec()], path)
+    with path.open(encoding="utf-8", newline="") as f:
+        header = next(csv.reader(f))
+    assert header == ["image_path", "patient_id", "label", "severity", "note"]
+
+
+def test_read_accepts_manifest_without_note_column(tmp_path: Path) -> None:
+    path = tmp_path / "manifest.csv"
+    _write_csv(
+        path,
+        ["image_path", "patient_id", "label", "severity"],
+        [["red_mild/a.png", "p1", "red", "mild"]],
+    )
+    assert read_manifest(path) == [_rec("red_mild/a.png", "p1", "red", "mild")]
+
+
+@pytest.mark.parametrize("missing", ["image_path", "patient_id", "label", "severity"])
+def test_read_rejects_missing_required_column(tmp_path: Path, missing: str) -> None:
+    full = {"image_path": "red_mild/a.png", "patient_id": "p1", "label": "red", "severity": "mild"}
+    header = [c for c in full if c != missing]
+    path = tmp_path / "manifest.csv"
+    _write_csv(path, header, [[full[c] for c in header]])
+    with pytest.raises(ValueError):
+        read_manifest(path)
+
+
+@pytest.mark.parametrize(
+    "bad_row",
+    [
+        ["red_mild/b.png", "", "red", "mild", ""],  # patient_id 欠落
+        ["red_mild/b.png", "p2", "orange", "mild", ""],  # 未知の label
+        ["red_mild/b.png", "p2", "red", "weak", ""],  # 未知の severity
+        ["red_mild/b.png", "p2", "light_red", "strong", ""],  # 無効な組み合わせ
+        ["red_mild/a.png", "p2", "red", "mild", ""],  # image_path の重複
+        ["purple_mild/b.png", "p1", "purple", "mild", ""],  # 同一患者に異なる label
+    ],
+)
+def test_read_stops_on_invalid_row_instead_of_dropping_it(
+    tmp_path: Path, bad_row: list[str]
+) -> None:
+    path = tmp_path / "manifest.csv"
+    _write_csv(
+        path,
+        ["image_path", "patient_id", "label", "severity", "note"],
+        [["red_mild/a.png", "p1", "red", "mild", ""], bad_row],
+    )
+    with pytest.raises(ValueError):
+        read_manifest(path)
+
+
+def test_read_rejects_missing_file(tmp_path: Path) -> None:
+    with pytest.raises(ValueError):
+        read_manifest(tmp_path / "nothing.csv")
+
+
+def test_read_rejects_manifest_without_data_rows(tmp_path: Path) -> None:
+    path = tmp_path / "manifest.csv"
+    _write_csv(path, ["image_path", "patient_id", "label", "severity", "note"], [])
+    with pytest.raises(ValueError):
+        read_manifest(path)
+
+
+def test_read_error_message_has_no_patient_id(tmp_path: Path) -> None:
+    path = tmp_path / "manifest.csv"
+    _write_csv(
+        path,
+        ["image_path", "patient_id", "label", "severity", "note"],
+        [
+            [f"red_mild/{SECRET_FILE_STEM}.png", SECRET_PATIENT, "red", "mild", ""],
+            [f"pale_mild/{SECRET_FILE_STEM}b.png", SECRET_PATIENT, "pale", "mild", ""],
+        ],
+    )
+    with pytest.raises(ValueError) as exc_info:
+        read_manifest(path)
+    _assert_no_pii(str(exc_info.value), SECRET_PATIENT, SECRET_FILE_STEM)
+
+
+def test_read_logs_have_no_patient_id(tmp_path: Path, caplog: pytest.LogCaptureFixture) -> None:
+    path = tmp_path / "manifest.csv"
+    write_manifest([_rec(f"red_mild/{SECRET_FILE_STEM}.png", SECRET_PATIENT, "red", "mild")], path)
+    with caplog.at_level(logging.DEBUG):
+        read_manifest(path)
+    _assert_no_pii(caplog.text, SECRET_PATIENT, SECRET_FILE_STEM)
+
+
+# --- build_manifest_records --------------------------------------------------------------------
+
+
+def test_build_maps_every_dir_to_test01_label_and_severity(tmp_path: Path) -> None:
+    images = tmp_path / "images"
+    for i, dir_name in enumerate(sorted(TEST01_TABLE)):
+        _save_png(images / dir_name / f"img{i:03d}.png")
+
+    records = build_manifest_records(images)
+
+    assert len(records) == 9
+    for r in records:
+        dir_name, file_name = r.image_path.split("/")
+        assert (r.label, r.severity) == TEST01_TABLE[dir_name]
+        # 1 患者 1 枚のため画像 ID（ファイル名の stem）を patient_id とする（SPEC_01）
+        assert r.patient_id == Path(file_name).stem
+        assert r.note == ""
+
+
+def test_build_uses_path_relative_to_images_dir(tmp_path: Path) -> None:
+    images = tmp_path / "images"
+    _save_png(images / "red_mild" / "x1.png")
+    _save_png(images / "red_mild" / "x2.png")
+
+    records = build_manifest_records(images)
+
+    assert sorted(r.image_path for r in records) == ["red_mild/x1.png", "red_mild/x2.png"]
+    for r in records:
+        assert resolve_image_path(images, r).is_file()
+
+
+def test_build_output_passes_read_after_write(tmp_path: Path) -> None:
+    images = tmp_path / "images"
+    for i, dir_name in enumerate(sorted(TEST01_TABLE)):
+        _save_png(images / dir_name / f"img{i:03d}.png")
+    records = build_manifest_records(images)
+    write_manifest(records, tmp_path / "manifest.csv")
+    assert read_manifest(tmp_path / "manifest.csv") == records
+
+
+@pytest.mark.parametrize("dir_name", ["light_red_strong", "orange_mild", "淡紅（正常）", "misc"])
+def test_build_rejects_unexpected_dir_name(tmp_path: Path, dir_name: str) -> None:
+    images = tmp_path / "images"
+    _save_png(images / "red_mild" / "a.png")
+    _save_png(images / dir_name / "b.png")
+    with pytest.raises(ValueError):
+        build_manifest_records(images)
+
+
+@pytest.mark.parametrize("file_name", ["b.jpg", "b.txt", "b", "Thumbs.db"])
+def test_build_rejects_non_png_file(tmp_path: Path, file_name: str) -> None:
+    images = tmp_path / "images"
+    _save_png(images / "red_mild" / "a.png")
+    (images / "red_mild" / file_name).write_bytes(b"dummy")
+    with pytest.raises(ValueError):
+        build_manifest_records(images)
+
+
+def test_build_rejects_subdirectory_in_class_dir(tmp_path: Path) -> None:
+    # 実データは 9 フォルダの直下に画像がありサブフォルダは無い（TEST_01）
+    images = tmp_path / "images"
+    _save_png(images / "red_mild" / "a.png")
+    _save_png(images / "red_mild" / "nested" / "b.png")
+    with pytest.raises(ValueError):
+        build_manifest_records(images)
+
+
+def test_build_rejects_duplicate_stem_instead_of_guessing_patient(tmp_path: Path) -> None:
+    # 画像 ID を患者 ID と見なせない兆候があれば自動で続行しない（SPEC_01）
+    images = tmp_path / "images"
+    _save_png(images / "red_mild" / "same.png")
+    _save_png(images / "pale_mild" / "same.png")
+    with pytest.raises(ValueError):
+        build_manifest_records(images)
+
+
+def test_build_rejects_missing_images_dir(tmp_path: Path) -> None:
+    with pytest.raises(ValueError):
+        build_manifest_records(tmp_path / "images")
+
+
+def test_build_rejects_empty_images_dir(tmp_path: Path) -> None:
+    (tmp_path / "images").mkdir()
+    with pytest.raises(ValueError):
+        build_manifest_records(tmp_path / "images")
+
+
+def test_build_rejects_empty_class_dir(tmp_path: Path) -> None:
+    # 他のクラスに画像があっても，空のクラスディレクトリがあれば止める（SPEC_01 検証規則）．
+    images = tmp_path / "images"
+    _save_png(images / "red_mild" / "a.png")
+    (images / "pale_mild").mkdir()
+    with pytest.raises(ValueError, match="pale_mild"):
+        build_manifest_records(images)
+
+
+def test_build_error_message_has_no_file_name(tmp_path: Path) -> None:
+    images = tmp_path / "images"
+    _save_png(images / "red_mild" / "a.png")
+    (images / "red_mild" / f"{SECRET_FILE_STEM}.jpg").write_bytes(b"dummy")
+    with pytest.raises(ValueError) as exc_info:
+        build_manifest_records(images)
+    _assert_no_pii(str(exc_info.value), SECRET_FILE_STEM)
+
+
+def test_build_duplicate_stem_error_message_has_no_file_name(tmp_path: Path) -> None:
+    images = tmp_path / "images"
+    _save_png(images / "red_mild" / f"{SECRET_FILE_STEM}.png")
+    _save_png(images / "pale_mild" / f"{SECRET_FILE_STEM}.png")
+    with pytest.raises(ValueError) as exc_info:
+        build_manifest_records(images)
+    _assert_no_pii(str(exc_info.value), SECRET_FILE_STEM)
+
+
+def test_build_logs_have_no_file_name(tmp_path: Path, caplog: pytest.LogCaptureFixture) -> None:
+    images = tmp_path / "images"
+    _save_png(images / "red_mild" / f"{SECRET_FILE_STEM}.png")
+    with caplog.at_level(logging.DEBUG):
+        build_manifest_records(images)
+    _assert_no_pii(caplog.text, SECRET_FILE_STEM)
diff --git a/tests/data/test_split.py b/tests/data/test_split.py
new file mode 100644
index 0000000..caa7675
--- /dev/null
+++ b/tests/data/test_split.py
@@ -0,0 +1,316 @@
+"""患者単位分割のテスト（SPEC_02「データ分割」・SPEC_01「patient_id について」）.
+
+最重要: 同一 patient_id が複数の分割に跨らないこと．1 患者に複数枚ある manifest でも同様．
+"""
+
+import logging
+import random
+from collections import Counter
+
+import pytest
+
+from tias_judge_model.data.classes import CLASS_SLUGS, VALID_SEVERITIES
+from tias_judge_model.data.manifest import ManifestRecord
+from tias_judge_model.data.split import (
+    Fold,
+    SplitResult,
+    count_by_class,
+    count_by_class_severity,
+    make_kfold_splits,
+    patient_labels,
+    select_records,
+    split_train_val_test,
+)
+
+SEED = 42
+
+
+def make_records(
+    patients_per_class: int | dict[str, int], images_per_patient: int = 1, prefix: str = "pt"
+) -> list[ManifestRecord]:
+    """クラスごとに指定人数の患者を持つ合成 manifest を作る（1 患者 images_per_patient 枚）."""
+    if isinstance(patients_per_class, int):
+        patients_per_class = dict.fromkeys(CLASS_SLUGS, patients_per_class)
+    records = []
+    for label, n_patients in patients_per_class.items():
+        severities = VALID_SEVERITIES[label]
+        for p in range(n_patients):
+            patient_id = f"{prefix}_{label}_{p:04d}"
+            for k in range(images_per_patient):
+                severity = severities[(p + k) % len(severities)]
+                records.append(
+                    ManifestRecord(
+                        image_path=f"{label}_{severity}/{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)
+    return out
+
+
+def all_patients(records: list[ManifestRecord]) -> set[str]:
+    return {r.patient_id for r in records}
+
+
+def labels_in(patient_ids: tuple[str, ...], records: list[ManifestRecord]) -> Counter[str]:
+    mapping = patient_labels(records)
+    return Counter(mapping[p] for p in patient_ids)
+
+
+# --- 単一分割 (train / val / test) ---
+
+
+@pytest.mark.parametrize("images_per_patient", [1, 3])
+def test_single_split_keeps_patients_disjoint(images_per_patient: int) -> None:
+    records = make_records(20, images_per_patient=images_per_patient)
+    result = split_train_val_test(records, val_ratio=0.15, test_ratio=0.15, seed=SEED)
+
+    train, val, test = set(result.train), set(result.val), set(result.test)
+    assert not train & val
+    assert not train & test
+    assert not val & test
+    assert train | val | test == all_patients(records)
+    # 各分割は患者 ID の重複を含まない
+    for part in (result.train, result.val, result.test):
+        assert len(part) == len(set(part))
+
+
+def test_single_split_puts_all_images_of_a_patient_in_same_split() -> None:
+    records = make_records(12, images_per_patient=4)
+    result = split_train_val_test(records, val_ratio=0.2, test_ratio=0.2, seed=SEED)
+
+    selected = {
+        name: select_records(records, ids)
+        for name, ids in (("train", result.train), ("val", result.val), ("test", result.test))
+    }
+    assert sum(len(v) for v in selected.values()) == len(records)
+    for name, recs in selected.items():
+        for r in recs:
+            images_of_patient = [x for x in records if x.patient_id == r.patient_id]
+            assert all(x in recs for x in images_of_patient), name
+
+
+def test_single_split_with_uneven_images_per_patient_stays_disjoint() -> None:
+    # 1 患者の枚数がばらつく manifest（将来の複数枚追加を想定）
+    base = make_records(10, images_per_patient=1, prefix="one")
+    many = make_records(10, images_per_patient=5, prefix="many")
+    records = base + many
+    result = split_train_val_test(records, val_ratio=0.15, test_ratio=0.15, seed=SEED)
+
+    groups = [set(result.train), set(result.val), set(result.test)]
+    for patient in all_patients(records):
+        assert sum(patient in g for g in groups) == 1
+
+
+def test_single_split_is_reproducible_with_same_seed() -> None:
+    records = make_records(20)
+    a = split_train_val_test(records, val_ratio=0.15, test_ratio=0.15, seed=SEED)
+    b = split_train_val_test(records, val_ratio=0.15, test_ratio=0.15, seed=SEED)
+    assert a == b
+
+
+def test_single_split_changes_with_different_seed() -> None:
+    records = make_records(30)
+    a = split_train_val_test(records, val_ratio=0.15, test_ratio=0.15, seed=0)
+    b = split_train_val_test(records, val_ratio=0.15, test_ratio=0.15, seed=1)
+    assert a != b
+
+
+@pytest.mark.parametrize("images_per_patient", [1, 3])
+def test_single_split_does_not_depend_on_input_order(images_per_patient: int) -> None:
+    records = make_records(20, images_per_patient=images_per_patient)
+    expected = split_train_val_test(records, val_ratio=0.15, test_ratio=0.15, seed=SEED)
+    for shuffle_seed in range(3):
+        actual = split_train_val_test(
+            shuffled(records, shuffle_seed), val_ratio=0.15, test_ratio=0.15, seed=SEED
+        )
+        assert actual == expected
+    assert (
+        split_train_val_test(list(reversed(records)), val_ratio=0.15, test_ratio=0.15, seed=SEED)
+        == expected
+    )
+
+
+def test_single_split_is_stratified_by_class() -> None:
+    # 実データに近い不均衡な分布（TEST_01 の 1/10 程度）
+    per_class = {"pale": 10, "light_red": 34, "red": 12, "dark_red": 38, "purple": 15}
+    records = make_records(per_class)
+    result = split_train_val_test(records, val_ratio=0.15, test_ratio=0.15, seed=SEED)
+
+    for part in (result.train, result.val, result.test):
+        counts = labels_in(part, records)
+        assert set(counts) == set(CLASS_SLUGS), "各分割に全クラスが含まれること"
+
+    # 各クラスで val / test の人数が比率どおり（端数は 1 人以内）
+    for part in (result.val, result.test):
+        counts = labels_in(part, records)
+        for label, n in per_class.items():
+            assert abs(counts[label] - n * 0.15) <= 1, label
+
+
+def test_single_split_sizes_follow_ratios() -> None:
+    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
+
+
+def test_single_split_to_dict_contains_all_parts() -> None:
+    result = split_train_val_test(make_records(10), val_ratio=0.2, test_ratio=0.2, seed=SEED)
+    d = result.to_dict()
+    assert set(d) == {"train", "val", "test"}
+    assert d["train"] == list(result.train)
+    assert isinstance(result, SplitResult)
+
+
+def test_single_split_rejects_empty_records() -> None:
+    with pytest.raises(ValueError):
+        split_train_val_test([], val_ratio=0.15, test_ratio=0.15, seed=SEED)
+
+
+@pytest.mark.parametrize(
+    ("val_ratio", "test_ratio"), [(0.5, 0.5), (0.6, 0.5), (0.0, 0.2), (0.2, -0.1), (1.0, 0.1)]
+)
+def test_single_split_rejects_invalid_ratios(val_ratio: float, test_ratio: float) -> None:
+    with pytest.raises(ValueError):
+        split_train_val_test(make_records(20), val_ratio, test_ratio, seed=SEED)
+
+
+def test_single_split_rejects_patient_with_conflicting_labels() -> None:
+    records = make_records(10)
+    conflict = ManifestRecord(
+        image_path="purple_mild/extra.png",
+        patient_id=records[0].patient_id,
+        label="purple",
+        severity="mild",
+    )
+    assert records[0].label != "purple"
+    with pytest.raises(ValueError):
+        split_train_val_test([*records, conflict], val_ratio=0.15, test_ratio=0.15, seed=SEED)
+
+
+def test_split_logs_have_no_patient_id(caplog: pytest.LogCaptureFixture) -> None:
+    records = make_records(10, prefix="SECRETPT")
+    with caplog.at_level(logging.DEBUG):
+        split_train_val_test(records, val_ratio=0.2, test_ratio=0.2, seed=SEED)
+        make_kfold_splits(records, n_folds=5, seed=SEED)
+    assert "SECRETPT" not in caplog.text
+
+
+# --- K-fold 交差検証 ---
+
+
+@pytest.mark.parametrize("images_per_patient", [1, 3])
+def test_kfold_held_out_covers_all_patients_exactly_once(images_per_patient: int) -> None:
+    records = make_records(12, images_per_patient=images_per_patient)
+    folds = make_kfold_splits(records, n_folds=5, seed=SEED)
+
+    assert len(folds) == 5
+    assert [f.index for f in folds] == list(range(5))
+    held_out_all = [p for f in folds for p in f.held_out]
+    assert len(held_out_all) == len(set(held_out_all)), "held_out が fold 間で重複しない"
+    assert set(held_out_all) == all_patients(records)
+
+
+@pytest.mark.parametrize("images_per_patient", [1, 3])
+def test_kfold_train_and_held_out_are_disjoint(images_per_patient: int) -> None:
+    records = make_records(12, images_per_patient=images_per_patient)
+    for fold in make_kfold_splits(records, n_folds=5, seed=SEED):
+        assert isinstance(fold, Fold)
+        assert not set(fold.train) & set(fold.held_out)
+        assert set(fold.train) | set(fold.held_out) == all_patients(records)
+
+
+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")
+    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)
+        assert not {r.patient_id for r in train_recs} & {r.patient_id for r in held_recs}
+        assert len(train_recs) + len(held_recs) == len(records)
+
+
+def test_kfold_is_reproducible_with_same_seed() -> None:
+    records = make_records(12)
+    assert make_kfold_splits(records, 5, seed=SEED) == make_kfold_splits(records, 5, seed=SEED)
+
+
+def test_kfold_changes_with_different_seed() -> None:
+    records = make_records(12)
+    assert make_kfold_splits(records, 5, seed=0) != make_kfold_splits(records, 5, seed=1)
+
+
+@pytest.mark.parametrize("images_per_patient", [1, 3])
+def test_kfold_does_not_depend_on_input_order(images_per_patient: int) -> None:
+    records = make_records(12, images_per_patient=images_per_patient)
+    expected = make_kfold_splits(records, 5, seed=SEED)
+    for shuffle_seed in range(3):
+        assert make_kfold_splits(shuffled(records, shuffle_seed), 5, seed=SEED) == expected
+
+
+def test_kfold_is_stratified_by_class() -> None:
+    per_class = {"pale": 10, "light_red": 34, "red": 12, "dark_red": 38, "purple": 15}
+    records = make_records(per_class)
+    for fold in make_kfold_splits(records, n_folds=5, seed=SEED):
+        counts = labels_in(fold.held_out, records)
+        assert set(counts) == set(CLASS_SLUGS), "各 fold の held_out に全クラスが含まれること"
+        for label, n in per_class.items():
+            assert abs(counts[label] - n / 5) <= 1, label
+
+
+@pytest.mark.parametrize("n_folds", [1, 0, -1])
+def test_kfold_rejects_n_folds_below_two(n_folds: int) -> None:
+    with pytest.raises(ValueError):
+        make_kfold_splits(make_records(10), n_folds=n_folds, seed=SEED)
+
+
+def test_kfold_rejects_empty_records() -> None:
+    with pytest.raises(ValueError):
+        make_kfold_splits([], n_folds=5, seed=SEED)
+
+
+def test_kfold_rejects_patient_with_conflicting_labels() -> None:
+    records = make_records(10)
+    conflict = ManifestRecord(
+        image_path="purple_mild/extra.png",
+        patient_id=records[0].patient_id,
+        label="purple",
+        severity="mild",
+    )
+    with pytest.raises(ValueError):
+        make_kfold_splits([*records, conflict], n_folds=5, seed=SEED)
+
+
+# --- 集計 ---
+
+
+def test_patient_labels_maps_each_patient_once() -> None:
+    records = make_records(3, images_per_patient=2)
+    mapping = patient_labels(records)
+    assert len(mapping) == 15
+    for r in records:
+        assert mapping[r.patient_id] == r.label
+
+
+def test_count_by_class_lists_all_classes_in_id_order() -> None:
+    records = make_records({"red": 2, "purple": 1}, images_per_patient=2)
+    counts = count_by_class(records)
+    assert list(counts) == list(CLASS_SLUGS)
+    assert counts == {"pale": 0, "light_red": 0, "red": 4, "dark_red": 0, "purple": 2}
+
+
+def test_count_by_class_severity_counts_pairs() -> None:
+    records = make_records({"red": 3, "light_red": 2})
+    counts = count_by_class_severity(records)
+    assert counts == {("light_red", "normal"): 2, ("red", "strong"): 2, ("red", "mild"): 1}
+    # クラス ID 順に並ぶ
+    assert [label for label, _ in counts][0] == "light_red"
diff --git a/tests/scripts/test_make_synthetic_dataset.py b/tests/scripts/test_make_synthetic_dataset.py
new file mode 100644
index 0000000..7f4a5f2
--- /dev/null
+++ b/tests/scripts/test_make_synthetic_dataset.py
@@ -0,0 +1,128 @@
+"""合成データ生成スクリプトのテスト.
+
+仕様: SPEC_01「データ契約」（9 ディレクトリ + manifest.csv）・TEST_01「画像の性質」
+（PNG・RGB でアルファなし・マスク外は黒 (0, 0, 0)）・同じ seed で同じ出力．
+"""
+
+import importlib.util
+import sys
+from pathlib import Path
+from types import ModuleType
+
+import numpy as np
+import pytest
+from PIL import Image
+
+from tias_judge_model.data.classes import parse_dir_name
+from tias_judge_model.data.manifest import read_manifest, resolve_image_path
+from tias_judge_model.data.split import make_kfold_splits, split_train_val_test
+
+SCRIPT_PATH = Path(__file__).resolve().parents[2] / "scripts" / "make_synthetic_dataset.py"
+
+TEST01_DIRS = {
+    "light_red_normal",
+    "dark_red_strong",
+    "dark_red_mild",
+    "purple_mild",
+    "red_strong",
+    "red_mild",
+    "purple_strong",
+    "pale_strong",
+    "pale_mild",
+}
+
+
+@pytest.fixture(scope="module")
+def script() -> ModuleType:
+    spec = importlib.util.spec_from_file_location("make_synthetic_dataset", 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
+
+
+def _run(script: ModuleType, out: Path, per_dir: int = 3, seed: int = 0) -> None:
+    code = script.main(["--out", str(out), "--per-dir", str(per_dir), "--seed", str(seed)])
+    assert code == 0
+
+
+def _snapshot(root: Path) -> dict[str, bytes]:
+    return {
+        p.relative_to(root).as_posix(): p.read_bytes()
+        for p in sorted(root.rglob("*"))
+        if p.is_file() and p.suffix in {".png", ".csv"}
+    }
+
+
+def test_outputs_nine_spec_directories_and_manifest(script: ModuleType, tmp_path: Path) -> None:
+    out = tmp_path / "syn"
+    _run(script, out, per_dir=3)
+
+    images = out / "images"
+    assert {p.name for p in images.iterdir() if p.is_dir()} == TEST01_DIRS
+    for d in images.iterdir():
+        assert len(list(d.glob("*.png"))) == 3
+    assert (out / "manifest.csv").is_file()
+
+
+def test_manifest_passes_reading_and_validation(script: ModuleType, tmp_path: Path) -> None:
+    out = tmp_path / "syn"
+    _run(script, out, per_dir=3)
+
+    records = read_manifest(out / "manifest.csv")
+    assert len(records) == 27
+    assert len({r.patient_id for r in records}) == 27  # 1 患者 1 枚（実データと同じ前提）
+    for r in records:
+        dir_name = r.image_path.split("/")[0]
+        assert (r.label, r.severity) == parse_dir_name(dir_name)
+        assert resolve_image_path(out / "images", r).is_file()
+
+
+def test_same_seed_produces_identical_output(script: ModuleType, tmp_path: Path) -> None:
+    _run(script, tmp_path / "a", seed=5)
+    _run(script, tmp_path / "b", seed=5)
+    a, b = _snapshot(tmp_path / "a"), _snapshot(tmp_path / "b")
+    assert a and a == b
+
+
+def test_different_seed_produces_different_images(script: ModuleType, tmp_path: Path) -> None:
+    _run(script, tmp_path / "a", seed=1)
+    _run(script, tmp_path / "b", seed=2)
+    a, b = _snapshot(tmp_path / "a"), _snapshot(tmp_path / "b")
+    assert {k: v for k, v in a.items() if k.endswith(".png")} != {
+        k: v for k, v in b.items() if k.endswith(".png")
+    }
+
+
+def test_images_are_rgb_png_with_black_corners(script: ModuleType, tmp_path: Path) -> None:
+    out = tmp_path / "syn"
+    _run(script, out, per_dir=3)
+
+    pngs = sorted((out / "images").rglob("*.png"))
+    assert len(pngs) == 27
+    for png in pngs:
+        with Image.open(png) as img:
+            assert img.format == "PNG"
+            assert img.mode == "RGB"  # アルファチャンネルなし（TEST_01）
+            pixels = np.asarray(img)  # (H, W, 3)
+        h, w, _ = pixels.shape
+        for y, x in ((0, 0), (0, w - 1), (h - 1, 0), (h - 1, w - 1)):
+            assert tuple(int(v) for v in pixels[y, x]) == (0, 0, 0)
+        # 舌の代わりの前景（黒以外）も描かれている
+        assert (pixels.sum(axis=2) > 0).any()
+
+
+def test_synthetic_manifest_can_be_split_by_patient(script: ModuleType, tmp_path: Path) -> None:
+    out = tmp_path / "syn"
+    _run(script, out, per_dir=5)
+    records = read_manifest(out / "manifest.csv")
+
+    result = split_train_val_test(records, val_ratio=0.15, test_ratio=0.15, seed=0)
+    assert not set(result.train) & set(result.val)
+    assert not set(result.train) & set(result.test)
+    assert not set(result.val) & set(result.test)
+
+    folds = make_kfold_splits(records, n_folds=5, seed=0)
+    held_out = [p for f in folds for p in f.held_out]
+    assert sorted(held_out) == sorted({r.patient_id for r in records})
diff --git a/tests/test_schema.py b/tests/test_schema.py
new file mode 100644
index 0000000..eb07514
--- /dev/null
+++ b/tests/test_schema.py
@@ -0,0 +1,120 @@
+"""設定スキーマのテスト（SPEC_01 基本方針 3・testing ルール必須対象 5）."""
+
+from pathlib import Path
+
+import pytest
+from pydantic import ValidationError
+
+from tias_judge_model.schema import DATA_ROOT_ENV_VAR, ExperimentConfig, load_config
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+
+VALID_YAML = """\
+data:
+  root: some/data
+  manifest: manifest.csv
+split:
+  seed: 7
+  val_ratio: 0.1
+  test_ratio: 0.2
+  n_folds: 5
+"""
+
+
+def _write(tmp_path: Path, text: str) -> Path:
+    path = tmp_path / "config.yaml"
+    path.write_text(text, encoding="utf-8")
+    return path
+
+
+def test_load_valid_config(tmp_path: Path) -> None:
+    config = load_config(_write(tmp_path, VALID_YAML), environ={})
+    assert isinstance(config, ExperimentConfig)
+    assert config.data.root == Path("some/data")
+    assert config.data.manifest_path == Path("some/data") / "manifest.csv"
+    assert config.data.images_dir == Path("some/data") / "images"
+    assert config.split.seed == 7
+    assert config.split.val_ratio == pytest.approx(0.1)
+    assert config.split.test_ratio == pytest.approx(0.2)
+    assert config.split.n_folds == 5
+
+
+def test_split_section_is_optional(tmp_path: Path) -> None:
+    config = load_config(_write(tmp_path, "data:\n  root: d\n"), environ={})
+    assert config.split.n_folds == 5  # SPEC_02: 結論を出すときは 5-fold
+    assert config.split.val_ratio + config.split.test_ratio < 1.0
+
+
+@pytest.mark.parametrize("name", ["synthetic.yaml", "newton.yaml"])
+def test_repository_configs_are_valid(name: str) -> None:
+    config = load_config(REPO_ROOT / "configs" / name, environ={})
+    assert config.split.n_folds == 5
+
+
+def test_env_var_overrides_yaml_data_root(tmp_path: Path) -> None:
+    env_root = tmp_path / "from_env"
+    config = load_config(_write(tmp_path, VALID_YAML), environ={DATA_ROOT_ENV_VAR: str(env_root)})
+    assert DATA_ROOT_ENV_VAR == "TIAS_DATA_ROOT"
+    assert config.data.root == env_root
+    assert config.data.manifest_path == env_root / "manifest.csv"
+
+
+def test_env_var_supplies_root_missing_from_yaml(tmp_path: Path) -> None:
+    config = load_config(
+        _write(tmp_path, "split:\n  seed: 1\n"), environ={DATA_ROOT_ENV_VAR: "env/root"}
+    )
+    assert config.data.root == Path("env/root")
+
+
+def test_yaml_root_used_when_env_var_absent(tmp_path: Path) -> None:
+    config = load_config(_write(tmp_path, VALID_YAML), environ={"OTHER": "x"})
+    assert config.data.root == Path("some/data")
+
+
+def test_os_environ_is_used_by_default(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv(DATA_ROOT_ENV_VAR, "from/os/environ")
+    config = load_config(_write(tmp_path, VALID_YAML))
+    assert config.data.root == Path("from/os/environ")
+
+
+@pytest.mark.parametrize(
+    "split_yaml",
+    [
+        "  val_ratio: 0.5\n  test_ratio: 0.5\n",  # 合計 1
+        "  val_ratio: 0.6\n  test_ratio: 0.5\n",  # 合計 1 超
+        "  val_ratio: -0.1\n",
+        "  test_ratio: 1.0\n",
+        "  n_folds: 1\n",
+        "  n_folds: 0\n",
+        "  seed: not_a_number\n",
+        "  n_foldz: 5\n",  # 未知のキー（綴り間違い）
+    ],
+)
+def test_invalid_split_is_rejected(tmp_path: Path, split_yaml: str) -> None:
+    text = "data:\n  root: d\nsplit:\n" + split_yaml
+    with pytest.raises(ValidationError):
+        load_config(_write(tmp_path, text), environ={})
+
+
+@pytest.mark.parametrize(
+    "text",
+    [
+        "split:\n  seed: 1\n",  # data が無い
+        "data:\n  manifest: m.csv\n",  # data.root が無い
+        "data:\n  root: d\n  rooot: e\n",  # data の未知のキー
+        "data:\n  root: d\nmodel: convnext\n",  # トップレベルの未知のキー
+    ],
+)
+def test_missing_required_or_unknown_key_is_rejected(tmp_path: Path, text: str) -> None:
+    with pytest.raises(ValidationError):
+        load_config(_write(tmp_path, text), environ={})
+
+
+def test_empty_yaml_is_rejected(tmp_path: Path) -> None:
+    with pytest.raises(ValidationError):
+        load_config(_write(tmp_path, ""), environ={})
+
+
+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={})