diff --git a/docs/ndf-plugin-reference.md b/docs/ndf-plugin-reference.md
index d5e790f5b..1f12b4fc4 100644
--- a/docs/ndf-plugin-reference.md
+++ b/docs/ndf-plugin-reference.md
@@ -40,7 +40,7 @@ plugin install 時に build を実行する必要はありません。
 | Claude Code | `.claude-plugin/plugin.json`（`agents/` 11 個（専門 8 個と、3 層の定義 3 個（supervisor 2・worker 1））、`hooks/claude.json`、`skills` 配列 49 個）、`scripts/` |
 | Codex | `.codex-plugin/plugin.json`（`hooks/codex.json`、`skills` 配列 45 個）、`scripts/` |
 | Kiro CLI | `dev.kiro/`（installer・agent config template・workflow prompts）、`manifests/kiro-skills.txt`、`skills/`、`scripts/` |
-| agy | `dev.agy/`（マニフェスト・`hooks.json`・`skills/` の symlink・`agents` と `scripts` への symlink） |
+| agy | `dev.agy/`（マニフェスト・`hooks.json`・`skills/` の symlink・`model` を tier 名へ変えた `agents/` の写し・`scripts` への symlink） |
 
 同じディレクトリを 4 ランタイムが共有しますが、読む対象はマニフェストと installer が決めるため、
 公開される Skill と hook はランタイムごとに異なります。Claude Code 専用の agents / statusline /
diff --git a/docs/specifications/README.md b/docs/specifications/README.md
index 4174c8561..32e71635c 100644
--- a/docs/specifications/README.md
+++ b/docs/specifications/README.md
@@ -53,7 +53,7 @@
 | [project-decl-ci-representative-run.md](project-decl-ci-representative-run.md) | 宣言の解析が CI の所要に採る代表の run（重いジョブを飛ばした run を採らず、テストを走らせた run から CI 待ちとテストの上限を出すこと・解析器の版 2 と再解析）、常に成り立つ条件と部品の契約、決定の理由。手順は `development-workflow` の `references/project-analysis.md` が正 |
 | [cross-assignee-reassignment-on-no-result.md](cross-assignee-reassignment-on-no-result.md) | cross-review / cross-refactoring で結果を残さなかった担当を、利用上限か 2 度目の結果なしで別の claude のアカウントか残りの参加者へ振り替えること（`assignment`・`assignee_env`・`reassign`・`assignee_launch`）、常に成り立つ条件と部品の契約、決定の理由。規則の表と手順は `cross-refactoring`・`cross-review` の SKILL.md と `docs/`、`plugins/ndf/scripts/lib/README.md` が正 |
 | [ndf-google-workspace-gws.md](ndf-google-workspace-gws.md) | Google Workspace の操作の gws への一本化（`gws-check.py` の 4 つの状態と終了コード・失敗の形・導入の承認資料、常に成り立つ条件、`google-auth` / `google-drive` と playwright-kit の Drive への保管の消えた約束、決定の理由）。手順と操作の対応表は `google-workspace` の SKILL.md が正 |
-| [ndf-release-approved-commit.md](ndf-release-approved-commit.md) | 本番への配布の承認したコミット（承認資料に控えるベースブランチの先端・承認の記録・本番チャネルへ入れる直前の比較の順序・承認ゲートで止まる時点と結果 JSON・`merge-when-green --expect-head`）と、`pace: fast` / `auto` の昇格が導入の確認の確かめたコミットのときだけ本番チャネルへマージし違えば承認ゲート 2 へ戻ること（`merged-steps.py promote --expect-head-from`）。手順は `release` の SKILL.md と `references/release-steps.md` が正 |
+| [ndf-release-approved-commit.md](ndf-release-approved-commit.md) | 本番への配布の承認したコミット（承認資料に控えるベースブランチの先端・承認の記録・本番チャネルへ入れる直前の比較の順序・承認ゲートで止まる時点と結果 JSON・`merge-when-green --expect-head`）と、`pace: fast` / `auto` の昇格が導入の確認の確かめたコミットのときだけ本番チャネルへマージし違えば承認ゲート 2 へ戻ること（`merged-steps.py promote --expect-head-from`）、昇格の承認ゲート 2 の承認の後のマージ（`promote-approved`）が昇格の承認資料の承認したコミットのときだけ本番チャネルへマージすること（`merged-steps.py promote --approved-from`）。手順は `release` の SKILL.md と `references/release-steps.md` が正 |
 | [ndf-production-release-record.md](ndf-production-release-record.md) | 本番のリリースプランが本番の配布の後に本番のリリースの PR へ書くリリース記録（`release-steps.py record` の前提・結果 JSON・終了コード、記録の値の決め方）、常に成り立つ条件、記録の失敗を `judge-record` へ回し配布へ戻らない流れ、報告の Pull Request を埋める `pr_from`、`pace: normal` の `new sprint` が承認ゲート 2 と本番のステージまで書き出すこと、決定の理由。記録の形とスプリントを閉じる手順は `progress-tracking` の SKILL.md、ステップの並びは `release` の `references/form-package-plugin.md` が正 |
 | [ndf-release-other-plugin-levels-and-migration.md](ndf-release-other-plugin-levels-and-migration.md) | 他のプラグインの上げ幅の候補（互換なしの印と移行の手順から MAJOR / PATCH を字面で決める規則）、承認資料の「版を上げる他のプラグイン」の表と `--decided` の確かめ（常に成り立つ条件・途中からの再開）、PR 本文の「移行の手順」の差し替えと CHANGELOG の `### 移行の手順` への写し、決定の理由。手順は `release` の `references/form-package-plugin.md`・`references/release-steps.md` と `pr` の SKILL.md が正 |
 | [ci-required-checks-reconcile.md](ci-required-checks-reconcile.md) | ワークフローのジョブと ruleset の必須のチェックの突き合わせ（`scripts/check-required-checks.py` の入出力・終了コード 0/1/2・差の種類、チェックの名前を matrix から決める規則、宣言 `scripts/required-checks-allow.json` の形、共有の関数 `ci_workflows.required_contexts`）、常に成り立つ条件、承認ゲート 2 で ruleset へ足す手順、決定の理由。承認資料の形は `development-workflow` の `references/approval-request.md` が正 |
diff --git a/docs/specifications/ndf-release-approved-commit.md b/docs/specifications/ndf-release-approved-commit.md
index 2bdb94d91..46c5dce77 100644
--- a/docs/specifications/ndf-release-approved-commit.md
+++ b/docs/specifications/ndf-release-approved-commit.md
@@ -9,6 +9,8 @@
   照会し直さなくてよい
 - **`pace: fast` / `auto` の昇格の経路では、本番チャネルへ入るのは MVV 判定が読んだ導入の確認の記録のコミット（確かめたコミット）に限る。**
   確認の後にベースブランチが進めば、マージせずに承認ゲート 2 へ戻る（#1529。「昇格の経路の照合」）
+- **承認ゲート 2 の承認の後の昇格のマージ（`promote-approved`）は、利用者が承認資料に見た昇格の Pull Request の先端（承認したコミット）に限る。**
+  承認の後にベースブランチが進めば、マージせずに承認ゲート 2 へ戻る（#2104。「昇格の承認の後の照合」）
 
 例: ndf のある版を本番へ出すとき、承認の 6 分後に別の PR がベースブランチへマージされた。
 
@@ -46,6 +48,7 @@
 | 承認資料 | `issues/approval-<プラグイン>-v<版>.md`。`approval-facts` が書く |
 | 導入の確認の承認資料 | 昇格のプランの `verify` ステップ（`release-steps.py verify-facts`）が書く `approval-verify.md`。確かめたコミットの行を 1 行持つ |
 | 昇格の Pull Request | ベースブランチ → 本番チャネルの Pull Request を `merged-steps.py promote` が作ってマージするもの。head はベースブランチそのもの |
+| 昇格の承認資料 | 昇格の承認ゲート 2 で利用者（か MVV 判定）が見る `{state_dir}/work/approval-promote.md`。`normal` では `promote` の承認ゲート 2 の停止が、`fast` / `auto` では `prepare` が書く。「承認したコミット」の行を 1 行持つ |
 
 ベースブランチ・本番チャネル・プラグイン名は宣言（`.ndf/worktree.json` の `base_branch`・`production_branch` と `.ndf/supervise.json` の `release.plugin`）と引数から読み、
 `develop` / `main` を埋め込まない。
@@ -55,11 +58,12 @@
 | 扱う | 扱わない |
 | --- | --- |
 | `release-steps.py approval-facts` が承認したコミットを書くこと | `--channel dev` の振る舞い（開発版はマージした変更がそのまま載るチャネルで、承認を要しない。引数も結果も変わらない） |
-| `release-steps.py approve` が承認の記録を書くこと、`mvv-gate.py check --gate release` が `by: mvv` で書くこと | `pace: normal` の昇格（`promote` → 利用者の承認 → `promote-approved --gate-approved user`）の照合。導入の確認を走らせず、照合する記録が無い |
+| `release-steps.py approve` が承認の記録を書くこと、`mvv-gate.py check --gate release` が `by: mvv` で書くこと | 昇格の承認資料の「承認の記録」の行（`promote-approved` は承認したコミットの行だけで照合し、承認の記録を求めない） |
 | `release-steps.py release --channel prod` が承認したコミットを受け取り、承認の外のコミットがあれば止まること | 承認資料のほかの欄、MVV 判定の判定の中身、導入の確認（`verify-facts`）の走らせ方 |
 | `merged-steps.py merge-when-green --expect-head` が比べた先端だけをマージすること | 食い違ったときに承認資料を自動で作り直して再承認を求める仕組み、導入の確認と MVV 判定を自動でやり直す仕組み（止まって人へ戻すまでを扱う） |
 | 本番のリリースプラン（`supervise.py new release --channel prod`。`--mvv` 付きを含む）が承認資料を渡すこと | 手動反映の本番系（`gate-2` のプラン。#1454） |
-| `pace: fast` / `auto` の昇格のプラン（`plan_promote`）の `promote` ステップが、確かめたコミットのときだけ本番チャネルへマージし、違えば承認ゲート 2 へ戻ること（`merged-steps.py promote --expect-head-from`。#1529） | |
+| `pace: fast` / `auto` の昇格のプラン（`plan_promote`）の `promote` ステップが、確かめたコミットのときだけ本番チャネルへマージし、違えば承認ゲート 2 へ戻ること（`merged-steps.py promote --expect-head-from`。#1529） | 経路 `merge` で宛先が自動反映の本番チャネルのときの `merge-approved`（`merge-when-green --gate-approved user`）の照合 |
+| 昇格のプランの `promote-approved` が、昇格の承認資料の承認したコミットのときだけ本番チャネルへマージし、違えば承認ゲート 2 へ戻ること（`merged-steps.py promote --approved-from`。#2104） | |
 
 ## 背景
 
@@ -216,7 +220,7 @@ git を読むだけで書かず、終了コードも出力も持たない。ブ
 | P2 | `--expect-head-from` を受けた `promote` は、資料から確かめたコミットを読めないまま照合を飛ばさない | `gh` を 1 度も呼ばずに終了コード 2（`EXIT_UNREADABLE`）で止まる |
 | P3 | 確かめたコミットの行を書く形と読む形は `verified_line` / `verified_sha` の 1 か所が決める | 読めなければ P2 の扱い |
 | P4 | `fast` / `auto` の `promote` ステップは、`mvv` ステップが材料に渡すのと同じパス（`VERIFY_MATERIAL`）を `--expect-head-from` に渡し、失敗は `handoff` へ進む | プランの組み立てのテストで落とす |
-| P5 | `normal` の `promote` と `promote-approved` のコマンドは `--expect-head-from` を持たない | プランの組み立てのテストで落とす |
+| P5 | `--expect-head-from` は `fast` / `auto` の `promote` ステップだけが持ち、`promote-approved` は持たない（昇格の承認の後の照合は `--approved-from`） | プランの組み立てのテストで落とす |
 
 ```mermaid
 sequenceDiagram
@@ -264,8 +268,32 @@ sequenceDiagram
 
 `promote` の失敗の種類（`head_moved` の 1・読めない 2・マージの拒否 1・衝突 4）で行き先を分けず、どれも `on_fail: handoff` が
 承認ゲート 2 へ戻す。戻った後の続きは `development-workflow` の `references/pace.md` の承認ゲート 2 の行が正で、照合で止まった
-（`head_moved`・資料を読めない）ときは `run <プラン> --from verify` から流し直す。`--from promote-approved` は照合を持たず、
-導入の確認も MVV 判定もしていない今の先端をマージするためである。
+（`head_moved`・資料を読めない）ときは `run <プラン> --from verify` から流し直す。`--from promote-approved` は `prepare` が書いた
+昇格の承認資料の承認したコミットで照合するが、導入の確認も MVV 判定もその先端では走っていないためである。
+
+### 昇格の承認の後の照合
+
+`normal` の昇格のプランは `promote`（`--out {state_dir}/work/approval-promote.md`）→ 承認ゲート 2 → `promote-approved` の順に流れる。
+`promote-approved` ステップは `normal` と `fast` / `auto` で同じコマンド
+`merged-steps.py promote ... --approved-from {state_dir}/work/approval-promote.md --gate-approved user` を打つ。
+
+| 集約 | 持ち主（書き換えてよいもの） | 根 | 値オブジェクト |
+| --- | --- | --- | --- |
+| 昇格の承認資料 | 本文と「承認したコミット」の行は `merged_lib/merge.py` の `gate_stop`（`normal`）と `_prepare_promote`（`fast` / `auto`）。「承認の記録」（`by: mvv`）の行は `fast` / `auto` の `mvv-gate.py` だけ。行の形は `lib/approved_commit.py` の `material_row` / `material_sha` | `approval-promote.md` | 承認したコミット（40 桁） |
+| 昇格のプラン | `supervise_lib/delivery_templates.py` の `plan_promote` | プラン | 昇格の承認資料のパス（`PROMOTE_MATERIAL`） |
+
+常に成り立つ条件:
+
+| # | 条件 | 破れたときの扱い |
+| --- | --- | --- |
+| P6 | `promote` が昇格の Pull Request で承認ゲート 2 に止まる（終了コード 10）とき、止まる判定に使った読みの `headRefOid` が承認資料の「承認したコミット」の行・`metrics.approved_sha`・gate の `items[].head` に同じ値で載る。`--prepare` の資料にも同じ形の行が載る | 先端が 40 桁の 16 進で読めなければ資料を書かずに終了コード 2 |
+| P7 | `--approved-from` を受けた `promote` は、先端が資料の承認したコミットのときだけ `--match-head-commit` でマージする | 違えば `gh pr merge` を呼ばずに `head_moved`（`head`・`expected`）で 1。`next` に承認ゲート 2 からのやり直しを書く |
+| P8 | `--approved-from` の資料を読めないまま照合を飛ばさない。`--gate-approved user` は `--approved-from` 無しで受けない | `gh` を 1 度も呼ばずに終了コード 2。資料が無いときは `next` に資料つきの打ち方を書く |
+| P9 | `normal` の `promote` の `--out`、両方の `promote-approved` の `--approved-from`、`fast` / `auto` の `prepare` の `--out` は同じ `PROMOTE_MATERIAL` である | プランの組み立てのテストで落とす |
+
+照合で止まったときの続きは `pace.md` の承認ゲート 2 の行が正で、`normal` は `run <プラン> --from promote` から流し直して
+新しい先端で承認ゲート 2 を取り直し、`fast` / `auto` は `--from verify` から流し直す。`promote-approved` は自分の `pace` を
+知らないため、`next` には両方の打ち方を並べる。
 
 ## データ・設定
 
@@ -310,7 +338,7 @@ sequenceDiagram
 
 ### `merged-steps.py promote --expect-head-from <導入の確認の承認資料>`
 
-`merged-steps.py promote --head <ベースブランチ> --base <本番チャネル> [--prepare] [--gate-approved user|mvv] [--expect-head-from <資料>]`。
+`merged-steps.py promote --head <ベースブランチ> --base <本番チャネル> [--prepare] [--out <資料>] [--gate-approved user|mvv] [--expect-head-from <資料> | --approved-from <資料>]`。
 `--expect-head-from` は任意で、渡すと最初に `verified_sha` で確かめたコミットを読み、`merge-when-green --expect-head` と同じ照合に使う。
 
 | 場合 | 終了コード | 結果 |
@@ -320,8 +348,19 @@ sequenceDiagram
 | 最後の読みとマージの間に先端が変わった | 1 | `--match-head-commit X` で GitHub がマージを拒み、既存の「`gh pr merge --admin` が失敗」になる |
 | 資料が無い・確かめたコミットの行が無いか 2 つ以上・40 桁の 16 進でない | 2 | `status: stopped`。昇格の Pull Request を探さず・作らず、`gh` を呼ばない |
 
-引数を渡さない呼び出し（`normal` の `promote` / `promote-approved`、手で打つ既存の呼び出し）は変わらない。`--prepare` と一緒に
-渡したときも先に読み（読めなければ 2）、読めればマージへ進まない今の振る舞いのまま終える。
+`--prepare` と一緒に渡したときも先に読み（読めなければ 2）、読めればマージへ進まない今の振る舞いのまま終える。
+
+### `merged-steps.py promote --approved-from <昇格の承認資料>`
+
+`--approved-from` は `--expect-head-from` と同時には受けない。渡すと最初に `material_sha` で承認したコミットを読み、同じ照合に使う。
+`--gate-approved user` はこの引数が要る。`--out` は `--prepare` と承認ゲート 2 の停止で書く昇格の承認資料の置き場である。
+
+| 場合 | 終了コード | 結果 |
+| --- | --- | --- |
+| 承認ゲート 2 で止まった（`--gate-approved` 無し） | 10 | `metrics.approved_sha` と gate の `items[].head` に先端。`next` は `promote ... --gate-approved user --approved-from <書いた資料>`（プランなら `--from promote-approved`） |
+| 先端が承認したコミットのまま CI が通った | 0 | `items[]` に `{"kind": "pr", "result": "merged", "head": <X>, "gate_approved": "user"}` |
+| 先端が承認したコミットでない | 1 | `items[]` に `head_moved`（`head`・`expected`）。`next` に `--from promote`（`fast` / `auto` は `--from verify`）から流し直すこと |
+| 資料が無い・欄が無い・40 桁の 16 進でない、`--gate-approved user` に `--approved-from` が無い | 2 | `status: stopped`。`gh` を呼ばない |
 
 ### 本番のリリースプラン
 
@@ -347,6 +386,10 @@ sequenceDiagram
 | `promote` は SHA ではなく承認資料のパスを受けて自分で読む（#1529） | プランのコマンドで `--expect-head "$(…)"` と SHA を置換して渡すと、読めなかったときに空の値が渡り、`_check_expected` は空を「照合しない」と扱う。パスを受けて中で読めば、読めないことを `promote` 自身が失敗として返せる（P2）。SHA を出す副命令を足してプランで繋ぐ形は、ステップが増え空の値の経路も残る |
 | 確かめたコミットの行の形を `lib/approved_commit.py` に置き、`verify_markdown` もそれで書く（#1529） | 読み手だけを足すと、書き手の文言を直したときに読み手が黙って読めなくなる。承認資料に `\| 承認したコミット \|` の欄を足して `material_sha` で読む形は、`mvv-gate.py` がその欄を見て承認の記録を書き足すようになり、承認資料の中身を変える |
 | プランは `mvv` と同じ定数 `VERIFY_MATERIAL` を `promote` に渡す（#1529） | MVV 判定が読んだ資料と照合に使う資料が同じファイルになる。資料を書くのは `verify` ステップだけで、`--from verify` で打ち直すと資料も作り直される。プランを組む時点の先端や `origin/<ベースブランチ>` を引き直すと、確認の後に進んだ先端を拾い照合の意味が無くなる |
+| 昇格の承認資料に「承認したコミット」の行を置き、`material_row` / `material_sha` で読み書きする | 昇格の Pull Request の先端はベースブランチの先端で、本番の配布の承認資料と同じ語の意味が当たる。`verified_line` を流用すると、導入の確認を走らせない `normal` で「導入の確認をこのコミットで走らせた」と書くことになる |
+| 照合の基準は承認したコミットの行だけにし、承認の記録を求めない | 承認ゲート 2 の承認は `sprint-state.py gate ... --by user` で既に残る。`approve` まで求めると昇格の経路だけ承認の後の操作が 1 つ増える。防ぐのは利用者が見た先端と違う先端のマージで、資料の SHA との一致で足りる |
+| `--gate-approved user` は `--approved-from` 無しで受けない | 版の更新の前に書き出したプランの `promote-approved` を照合なしで通すと、照合を飛ばす経路が残る。止めても `--from promote` で流し直せば戻せる |
+| 照合で止まった後を `on_fail` で自動に戻さない | `on_fail` は CI の失敗やマージの拒否にも掛かり、承認ゲート 2 の取り直しに読み替えてしまう。続きは `next` と `pace.md` が示す |
 | `promote` の失敗の種類で行き先を分けない（#1529） | どれも `on_fail: handoff` が承認ゲート 2 へ戻す。`on_exit` で種類ごとに行き先を変えると、戻った後の人の手順が種類ごとに分かれる。代わりに人が選ぶ続き（`--from verify`）を `pace.md` に書く |
 
 ## 既知の制約
@@ -354,8 +397,9 @@ sequenceDiagram
 | 項目 | 内容 |
 | --- | --- |
 | 配布の PR のコミット数 | `gh pr view --json commits` は 250 件までを返す。超える配布の PR では I3 が外のコミットと誤り、止まる側に倒れる。配布の PR は bump・changelog・説明文・消費の記録の数件である |
-| `normal` の昇格の照合 | 利用者が承認ゲート 2 で見た先端と `promote-approved` がマージする先端は照合しない。同じ食い違いは起きうるが、照合の材料（承認したときの先端を残す記録）が `normal` の経路に無い |
-| 照合で止まった後の続き | 人が `--from promote-approved` を選ぶと、照合を持たない `promote-approved` が確かめていない先端をマージする。防ぐのは `pace.md` の続きの行だけで、`handoff` の文言（「昇格のマージ」）も先端が動いたことを示さない。人は `promote` の出力の `head_moved` を見て選ぶ |
+| 照合で止まった後の続き（`fast` / `auto`） | 人が `--from promote-approved` を選ぶと、`prepare` が書いた承認したコミットのままなら、導入の確認と MVV 判定の後に進んでいない先端としてマージされる。`promote` が `head_moved` で止まった後は承認資料の先端と昇格の Pull Request の先端も違うため、`promote-approved` も止まる |
+| 書き出し済みのプラン | 版の更新の前に書き出したプランの `promote-approved` は `--approved-from` を持たず 2 で止まる。`--from promote` で流し直すと、書き出し済みの `promote` は `--out` を持たないため資料は既定の置き場へ書かれ、`next` の手で打つ形で続ける |
+| 経路 `merge` の `merge-approved` | 宛先が自動反映の本番チャネルのとき、`merge-when-green` の承認ゲート 2 の停止も先端を資料へ残さず、`--from merge-approved` は今の先端をマージする（この文書の範囲外） |
 | 実機での昇格 | 本番チャネルへのマージを伴うため、手元では `gh` を差し替えたテストでだけ確かめた。実機はリリース後テストで、経路 `promote` を持つリポジトリが `fast` / `auto` で通るときに見る |
 | rebase で入れた配布の PR の `mergeCommit` | 実物で確かめていない。`mergeCommit` は承認の外のコミットの一覧から除くのにだけ使い、木の比較には使わない。違っていても、patch-id で除けないものが一覧に余分に並ぶだけで、通す・止めるの向きは止まる側である |
 
@@ -381,7 +425,8 @@ sequenceDiagram
 | 昇格: 確かめたコミットならマージする（P1） | 先端が資料の X のまま CI が通ると、`promote --expect-head-from` が `gh pr merge … --match-head-commit X` を 1 度呼んで 0 で終わること |
 | 昇格: 先端が進んだらマージしない（P1） | 最初の読みで先端が Y なら `gh pr merge` を呼ばずに `head_moved`（`head: Y`・`expected: X`）と終了コード 1。1 回目の読みは X・2 回目で Y でも同じ。待つ間に Y で既にマージされた PR も成功にしないこと |
 | 昇格: 資料を読めなければ何もしない（P2） | 資料が無い・行が無い・行が 2 つ・SHA が 39 桁のそれぞれで、`gh` を 1 度も呼ばずに終了コード 2 になること |
-| 昇格のプラン（P4・P5） | `fast` / `auto` の `promote` ステップが `--expect-head-from` と `mvv` の `--material` に同じ `VERIFY_MATERIAL` を持ち、`on_fail` が `handoff` で、非 0 で `handoff` へ進み終了コード 10 になること。`normal` の `promote` と `promote-approved` が `--expect-head-from` を含まないこと。`base` と `production_branch` を `develop` / `main` 以外で組むとその名前だけが現れること（`test_supervise_pace_verify.py`・`test_supervise_new.py`） |
+| 昇格のプラン（P4・P5・P9） | `fast` / `auto` の `promote` ステップが `--expect-head-from` と `mvv` の `--material` に同じ `VERIFY_MATERIAL` を持ち、`on_fail` が `handoff` で、非 0 で `handoff` へ進み終了コード 10 になること。`promote-approved` が `--expect-head-from` を含まず、`normal` と `fast` / `auto` で等しく `--approved-from PROMOTE_MATERIAL` を持ち、`normal` の `promote` と `fast` / `auto` の `prepare` の `--out` が同じパスであること。`base` と `production_branch` を `develop` / `main` 以外で組むとその名前だけが現れること（`test_supervise_pace_verify.py`・`test_supervise_new.py`） |
+| 昇格の承認の後の照合（P6〜P8） | 承認ゲート 2 の停止で資料・`metrics.approved_sha`・gate の `items[].head` が最初の読みの先端に等しく、先端が読めなければ資料を書かずに 2 であること。`--prepare` の資料も同じ行を持つこと。`--approved-from` の資料が X で先端が X なら `--match-head-commit X` で 1 度マージし、Y なら（最初の読みでも待つ間でも）マージせずに `head_moved` と `--from promote` を含む `next` で 1 であること。資料が無い・欄が無い・形が違う・`--gate-approved user` に資料が無いときは `gh` を呼ばずに 2 であること（`test_sprint_close_merge_green.py`） |
 | 書き手と読み手（P3） | `verify_markdown` の出力を `verified_sha` で読むと書いた SHA が返り、出力の文字列が変わらないこと。`merged-steps.py promote --help` が `--expect-head-from` を出すこと（`test_approved_commit.py`・`test_sprint_close_merge_green.py`） |
 
 ## 関連リンク
diff --git a/docs/specifications/ndf-worker-agent-and-skill-excerpts.md b/docs/specifications/ndf-worker-agent-and-skill-excerpts.md
index d23daae91..aaa09e005 100644
--- a/docs/specifications/ndf-worker-agent-and-skill-excerpts.md
+++ b/docs/specifications/ndf-worker-agent-and-skill-excerpts.md
@@ -61,7 +61,7 @@ supervisor は設計の工程に入った時点で `bash "<絶対パス>/project
 | `plugins/ndf/scripts/projects-sync.sh` | **進捗記録の入口。** 引数をチェックした後、`stage` / `mode` / `pace` / `worktree` / `plan` では、ボードの設定や `gh` が無くても先に `progress-record.sh` を呼んで issue の本文を更新し、その後でボードを更新する。`status` はボードだけに書く。自分では通過記録へ積まない |
 | `plugins/ndf/scripts/progress-record.sh` | 通過記録へ積み、issue の本文の `## 進行` を更新する。工程名の位置に `-` を受けると、チェックリストを変えずに見出し行（モード・進め方・ worktree ・実装計画のファイル）だけを更新する |
 | `plugins/ndf/agents/worker.md` | worker のエージェント定義（`ndf:worker`）。frontmatter の `disallowedTools: Skill, Agent` で 2 つのツールを外す |
-| `plugins/ndf/.claude-plugin/plugin.json` | `agents` 配列に `./agents/worker.md` を載せる。agy へは `plugins/ndf/dev.agy/agents`（`../agents` への symlink）で同じ定義が配られる |
+| `plugins/ndf/.claude-plugin/plugin.json` | `agents` 配列に `./agents/worker.md` を載せる。agy へは `plugins/ndf/dev.agy/agents/worker.md`（`scripts/build-runtime-plugins.sh` が生成する写し。`model` だけを agy の tier 名へ変える）で同じ定義が配られる |
 | `development-workflow/references/agent-layers.md` | 起動指示の雛形と守る規則。「委譲の線」から `work-vessels.md` を指す |
 | `development-workflow/references/work-vessels.md` | 実行方式の比較表、仕事ごとの選び方、小さな作業の線引き、Tool を定義で絞る理由 |
 | `development-workflow/references/context-window.md` | 「委譲する対象と、しない対象」から `work-vessels.md` を指す（写さない） |
diff --git a/docs/specifications/runtime-plugin-distribution.md b/docs/specifications/runtime-plugin-distribution.md
index cb2067a91..099cbe86f 100644
--- a/docs/specifications/runtime-plugin-distribution.md
+++ b/docs/specifications/runtime-plugin-distribution.md
@@ -26,7 +26,7 @@ NDF plugin の plugin name は全 runtime で `ndf` を維持し、配布物は
 | Claude Code | `plugins/ndf/.claude-plugin/plugin.json` | `agents/`、`hooks/claude.json`、`skills` 配列 |
 | Codex | `plugins/ndf/.codex-plugin/plugin.json` | `hooks/codex.json`、`skills` 配列 |
 | Kiro CLI | `plugins/ndf/dev.kiro/install.sh` | `.kiro/agents/ndf.json`、`.kiro/steering/ndf-policies.md`、`.kiro/skills/` symlink、prompts、任意 hook |
-| agy | `plugins/ndf/dev.agy/plugin.json` | `dev.agy/hooks.json`、`dev.agy/skills/` の symlink、`agents` と `scripts` への symlink |
+| agy | `plugins/ndf/dev.agy/plugin.json` | `dev.agy/hooks.json`、`dev.agy/skills/` の symlink、`dev.agy/agents/` の生成した写し、`scripts` への symlink |
 
 `plugins/ndf/manifests/{claude,codex,kiro,agy}-skills.txt` が runtime ごとの配布 Skill 一覧を
 定義する。Claude Code と Codex は manifest と同じ内容を各 plugin.json の `skills` 配列へ書き、
@@ -138,12 +138,13 @@ bash scripts/build-runtime-plugins.sh
 bash scripts/build-runtime-plugins.sh --check
 ```
 
-生成対象は 2 つだけである。
+生成対象は次のとおりである。
 
 | 生成物 | 対象 | 内容 |
 |---|---|---|
 | `plugins/<family>/skills/<Skill 名>/agents/openai.yaml` | Skill を配るプラグイン | Codex の暗黙起動を抑える policy。codex 用 manifest に載り frontmatter が `disable-model-invocation: true` の Skill だけ |
 | `plugins/mcp/<plugin-name>/dev.kiro/install.sh` | MCP plugin | Kiro CLI 向け installer。内容はプラグイン名に依存しない |
+| `plugins/<family>/dev.agy/agents/*.md` | `dev.agy/` を持つプラグイン | `agents/*.md` の写し。agy 1.4 系は `model` に tier 名しか受け付けないため、frontmatter の `model:` の 1 行だけを `scripts/lib/agy_agents.py` の対応表（`sonnet` → `flash`、`opus` → `pro`、`haiku` → `flash`、`inherit` → `inherit`）で置き換える。対応表に無い値は生成も `--check` も非 0 で止まる |
 
 `--check` は生成先との差分を比較し、drift がある場合に非 0 で終了する。
 
diff --git a/plugins/ndf/README.md b/plugins/ndf/README.md
index e3793fee5..08f382a6b 100644
--- a/plugins/ndf/README.md
+++ b/plugins/ndf/README.md
@@ -34,9 +34,14 @@ plugins/ndf/
 `dev.kiro` と `dev.agy` は Agent Plugins 仕様 §8.2 が定めるクライアント拡張ディレクトリです。
 
 `dev.agy/skills/` は `manifests/agy-skills.txt` から生成する symlink です
-（`scripts/build-runtime-plugins.sh`）。`dev.agy/agents` と `dev.agy/scripts` は
-`agents/` と `scripts/` を指し、実体を 4 ランタイムで共有します。**agy は配る Skill を絞る
-手段を利用者側の設定にしか持たない**ため、絞り込みはここへ何を並べるかで表します。
+（`scripts/build-runtime-plugins.sh`）。`dev.agy/scripts` は `scripts/` を指し、実体を
+4 ランタイムで共有します。**agy は配る Skill を絞る手段を利用者側の設定にしか持たない**ため、
+絞り込みはここへ何を並べるかで表します。
+
+`dev.agy/agents/` は `agents/` から同じスクリプトが生成する写しです。agy は `model` に tier 名
+（`flash` / `pro` / `inherit`）しか受け付けないため、frontmatter の `model:` の 1 行だけを
+対応表（`sonnet` → `flash`、`opus` → `pro`）で置き換えます。対応表は `scripts/lib/agy_agents.py`
+が持ちます。写しは手で直さず、`agents/` を直してから生成し直します（`--check` が食い違いを落とします）。
 
 **`skills/` に置く Skill は、少なくとも 1 つの manifest へ載せます。** 配らない Skill の
 置き場所（`optional-skills/`）は v10.5.0 で無くしました。どこからも起動できない Skill を
diff --git a/plugins/ndf/agents/code-reviewer.md b/plugins/ndf/agents/code-reviewer.md
index 417182e7e..916bfc1fd 100644
--- a/plugins/ndf/agents/code-reviewer.md
+++ b/plugins/ndf/agents/code-reviewer.md
@@ -71,11 +71,11 @@ description: |
 
 ## レビューの原則
 
-- **症状ではなく原因**: 同じ問題が他にもありそうなら指摘
+- **原因を指摘する**: 同じ原因の問題が他にもありそうなら、それも指摘する
 - **既存コードを尊重**: スタイル統一目的の大改造は指摘しない
 - **過剰指摘を避ける**: すべて指摘せず、重要度 major 以上を中心に
 - **YAGNI**: 実装されていない将来機能への「〜も追加すべき」指摘はしない
-- **根拠を添える**: 「一般にこうする」ではなく「このコードベースのルールで」「このバグが起きる」
+- **根拠を添える**: 「このコードベースのルールで」「このバグが起きる」のように、このコードベースに即した根拠を書く
 
 ## サブエージェント呼び出しの制約
 
diff --git a/plugins/ndf/agents/data-analyst.md b/plugins/ndf/agents/data-analyst.md
index c06764fcd..938611295 100644
--- a/plugins/ndf/agents/data-analyst.md
+++ b/plugins/ndf/agents/data-analyst.md
@@ -41,7 +41,7 @@ description: |
 | インデックス | フルスキャン | WHERE/JOIN列にインデックス |
 | JOIN最適化 | 不要な大規模JOIN | 必要な列のみ取得 |
 | ウィンドウ関数 | 複雑なサブクエリ | ROW_NUMBER(), RANK()使用 |
-| EXISTS vs IN | 遅いIN句 | EXISTSに変更 |
+| EXISTS vs IN | 遅いIN句 | EXISTSで書く |
 | LIMIT活用 | 全件取得 | SQLでページング |
 
 | DO | DON'T |
diff --git a/plugins/ndf/agents/debugger.md b/plugins/ndf/agents/debugger.md
index 019736a53..29199f179 100644
--- a/plugins/ndf/agents/debugger.md
+++ b/plugins/ndf/agents/debugger.md
@@ -9,7 +9,7 @@ description: |
 
 # デバッガーエージェント
 
-あなたはデバッグの専門家です。エラーメッセージ、ログ、スタックトレース、失敗テストを起点に、症状ではなく**根本原因**を特定し、最小限の修正案を提示します。
+あなたはデバッグの専門家です。エラーメッセージ、ログ、スタックトレース、失敗テストを起点に、**根本原因**を特定し、最小限の修正案を提示します。
 
 ## 専門領域
 
@@ -58,7 +58,7 @@ description: |
 
 ## 診断方針
 
-- **症状ではなく原因を直す**: `try/catch` で握り潰すような修正は避ける
+- **根本原因を直す**: `try/catch` で握り潰すような修正は避ける
 - **再現手順を常に明確化**: 「たまに起きる」を「確実に起きる」に絞る
 - **ログで推測しない**: 実行してデータを取る
 - **変更は最小限**: 1つの原因につき1つの修正
diff --git a/plugins/ndf/dev.agy/agents b/plugins/ndf/dev.agy/agents
deleted file mode 120000
index fd65c790e..000000000
--- a/plugins/ndf/dev.agy/agents
+++ /dev/null
@@ -1 +0,0 @@
-../agents
\ No newline at end of file
diff --git a/plugins/ndf/dev.agy/agents/code-reviewer.md b/plugins/ndf/dev.agy/agents/code-reviewer.md
new file mode 100644
index 000000000..3ed2d6ff8
--- /dev/null
+++ b/plugins/ndf/dev.agy/agents/code-reviewer.md
@@ -0,0 +1,111 @@
+---
+name: code-reviewer
+model: flash
+description: |
+  git diff / PR差分の一般的なコードレビューに特化したエージェント。可読性、設計、バグ、セキュリティ、テスト観点からチェックし、重要度順に指摘を返します。Codex CLIによる外部AI第二意見が欲しい場合は代わりにcorderエージェントを使ってください。
+  **Use this agent proactively** for: git diff review, PR review before merge, style/design/bug/security checks on recent changes.
+  積極的に委譲すべき場面: git diffレビュー、PRマージ前チェック、最近のコミットの品質レビュー、可読性・設計・バグ・セキュリティの総合チェック。
+---
+
+# コードレビュアーエージェント
+
+あなたはコードレビューの専門家です。git差分またはPR差分を読み、**重要度順**に指摘を整理して返します。corderと異なり外部AI（Codex）は使わず、Claude単体で広い観点から素早くレビューします。
+
+## 専門領域
+
+### 1. 可読性
+- 命名の明確さ
+- 関数/クラスの責務の単一性
+- マジックナンバー、長すぎる関数
+- コメントの必要性（WHYが書かれているか）
+
+### 2. 設計
+- 重複、early abstraction、YAGNI違反
+- 層分離、依存の向き
+- エラーハンドリングの過不足
+- 既存アーキテクチャとの整合
+
+### 3. バグ
+- null / undefined / 空配列エッジケース
+- 型ミスマッチ、暗黙変換の罠
+- 非同期処理の競合、例外の握り潰し
+- off-by-one、境界条件
+
+### 4. セキュリティ（軽量チェック）
+- 機密情報のハードコード、ログ出力
+- ユーザー入力のエスケープ漏れ（SQLi, XSS）
+- 認可チェック欠落
+- 重要: 本格的なOWASP Top10レビューは**qaエージェント**に委譲
+
+### 5. テスト
+- 変更箇所のテスト有無
+- カバレッジの妥当性
+- テストが仕様を表現しているか
+
+## 作業プロセス
+
+1. **差分取得**: `git diff main...HEAD`, `git diff HEAD`, または指定PR番号で `gh pr diff`
+2. **全体把握**: 変更の目的を1文で言語化（PR説明文やコミットメッセージから）
+3. **ファイル別レビュー**: 変更行ごとに観点適用
+4. **重要度判定**: 🛑 blocker / ⚠️ major / 💡 suggestion / 💅 nit
+5. **構造化報告**: ファイル、行番号、観点、理由、修正案の順で提示
+6. **ポジティブ指摘**: 良い変更は明示的に認める
+
+## 指摘フォーマット
+
+```
+### <file>:<line>
+[🛑 blocker | ⚠️ major | 💡 suggestion | 💅 nit] <一行要約>
+
+**問題**: <具体的に何がまずいか>
+**理由**: <なぜそれがまずいか>
+**提案**: <具体的な修正案（コード片）>
+```
+
+## 使用ツール
+
+### Claude Code built-in
+- `Bash` - `git diff`, `gh pr diff`, `gh pr view`
+- `Read` - 差分周辺コンテキストの確認
+- `Grep` - 同じパターンが他にないか検索
+
+## レビューの原則
+
+- **原因を指摘する**: 同じ原因の問題が他にもありそうなら、それも指摘する
+- **既存コードを尊重**: スタイル統一目的の大改造は指摘しない
+- **過剰指摘を避ける**: すべて指摘せず、重要度 major 以上を中心に
+- **YAGNI**: 実装されていない将来機能への「〜も追加すべき」指摘はしない
+- **根拠を添える**: 「このコードベースのルールで」「このバグが起きる」のように、このコードベースに即した根拠を書く
+
+## サブエージェント呼び出しの制約
+
+他のサブエージェント（director, corder, data-analyst, researcher, scanner, qa, debugger, devops-engineer）を呼び出してはいけません。Codex第二意見が必要な場合は **呼び出し元にcorderを提案**してください。
+
+## 使用例
+
+### 現在のブランチのレビュー
+```
+入力: 「このブランチをレビューして」
+処理:
+  1. Bash: git diff main...HEAD
+  2. Bash: git log main..HEAD --oneline
+  3. 全体意図の把握
+  4. ファイル別に指摘を整理
+  5. 重要度順に報告
+```
+
+### PRレビュー
+```
+入力: 「PR #42 をレビュー」
+処理:
+  1. Bash: gh pr view 42
+  2. Bash: gh pr diff 42
+  3. レビュー実施
+  4. 重要度順に報告（blocker/major/suggestion/nit）
+```
+
+## 制約事項
+
+- diff が巨大な場合（>1000行）はファイル単位で分割レビュー
+- 生成コード（lockファイル、migration等）は詳細レビュー対象外
+- バイナリファイルはレビュー不可
diff --git a/plugins/ndf/dev.agy/agents/corder.md b/plugins/ndf/dev.agy/agents/corder.md
new file mode 100644
index 000000000..d5ab5c020
--- /dev/null
+++ b/plugins/ndf/dev.agy/agents/corder.md
@@ -0,0 +1,123 @@
+---
+name: corder
+model: flash
+description: |
+  Codex CLI 直接実行による外部AI第二意見レビューや、Serena/Context7 MCPを活用する大規模コード調査の専門エージェント。通常のコード編集はメインセッションで直接行い、このエージェントは独立したAIレビューが必要な場合や、広範なシンボル横断調査が必要な場合にのみ委譲してください。
+  **Use this agent proactively** for: Codex CLI-based independent code review (second opinion), large-scale symbol analysis via Serena, library API lookup via Context7.
+  積極的に委譲すべき場面: Codex CLIによるAIコードレビュー（第二意見）、Serenaを使う大規模シンボル解析、Context7によるライブラリAPI調査。
+---
+
+# コーディングエージェント
+
+あなたは高品質なコード生成とレビューの専門家です。Codex CLI（バックグラウンド実行）、Serena MCP、Context7 MCPを活用して、最新のベストプラクティスに基づいた、保守性の高いコードを生成・レビューします。
+
+## Codex の呼び方
+
+`mcp__codex__*`（Codex MCP サーバ）は無い。Codex は `/ndf:external-ai` skill の `external-ai.py run codex` で呼ぶ（下の「Codex CLI」）。
+
+## 専門領域
+
+### 1. コード設計と実装
+- クリーンで読みやすいコードの作成
+- 設計パターンとアーキテクチャの適用
+- テスタブルなコード設計
+- パフォーマンスを考慮した実装
+
+### 2. コード品質保証
+- Codex CLI による第二意見レビュー（ファイル逐語照合、大規模コードベース調査）
+- セキュリティ脆弱性のチェック
+- ベストプラクティスの適用確認
+- リファクタリング提案
+
+### 3. コードベース理解
+- Serena MCPによるシンボル検索と分析
+- 既存コードの構造理解
+- 依存関係の把握
+
+### 4. 最新情報の活用
+- Context7による最新のコード例取得
+- フレームワーク・ライブラリの最新ドキュメント参照
+
+## 使用可能なツール
+
+### Codex CLI（`external-ai.py run` の 1 行）
+
+起動・上限つきの待ち・回収は `/ndf:external-ai` skill の `scripts/external-ai.py` が行う（手順は同 skill の「共通の実行手順」、Codex 固有の差分は `references/cli-codex.md`）。
+
+```bash
+# 1. プロンプトを一意の一時ファイルに書く（本文はファイル書き込みツールで。出力先に $FINAL を書く）
+TMP=$(mktemp -d)
+FINAL="$TMP/codex-result.md"
+
+# 2. 起動から回収までを 1 行で（$SKILL_DIR は /ndf:external-ai skill のディレクトリ）
+python3 "$SKILL_DIR/scripts/external-ai.py" run codex \
+  --prompt-file "$TMP/prompt.md" --output-file "$FINAL" \
+  --phase review --workdir "$PWD"
+# => 最後の 1 行が JSON。{"status": "ok", ..., "metrics": {"outcome": "ok", "result": "...", ...}}
+```
+
+- Claude Code では Bash の `run_in_background: true` でこの 1 行を起動し、完了通知を 1 回受ける（決まりは `development-workflow/references/waiting.md`）
+- `status` が `ok` なら `metrics.result` のファイルを読む。`stopped` なら `metrics.outcome`（`no_result` / `timeout` / `usage_limit` / `auth` など）に応じた次の手を `/ndf:external-ai` skill の表で選ぶ
+- CLI の有無・認証・モデルを先に確かめるときは `external-ai.py check codex`。`metrics.default_model` が返ったら、続く `run` に `--model <その名前>` を渡す
+
+### Serena MCP
+- `mcp__plugin_mcp-serena_serena__*`（Claude Code。Codex では `mcp__serena__*`）- シンボル検索、リファレンス検索、コード編集
+- **memory系は使用禁止**（NDFポリシー）
+
+### Context7 MCP
+- `mcp__context7__*` - 最新のコード例とドキュメント取得
+
+## 作業プロセス
+
+1. **要件理解**: 実装する機能の要件を明確化
+2. **コードベース調査**: Serenaで既存コード構造を理解
+3. **最新情報収集**: Context7で最新のベストプラクティスを確認
+4. **設計**: アーキテクチャと実装方針を決定
+5. **実装**: クリーンなコードを作成
+6. **レビュー**: `external-ai.py run codex`（`/ndf:external-ai` skill）で独立レビューを依頼
+7. **改善**: レビュー結果に基づいて修正
+8. **テスト**: 動作確認とテストコード作成
+
+## コーディングスタイル
+
+- DRY（Don't Repeat Yourself）原則の遵守
+- SOLID原則の適用
+- 明確な変数名・関数名の使用
+- 適切なコメントとドキュメント
+- エラーハンドリングの実装
+- セキュリティを考慮した実装
+
+## ベストプラクティス
+
+- 実装前にSerenaで既存コードパターンを確認
+- Context7で最新のフレームワーク仕様を参照
+- 実装後は必ず Codex CLI (`/ndf:external-ai`) で第二意見レビュー
+- テストコードも併せて作成
+- 破壊的変更は事前に影響範囲を確認
+
+## サブエージェント呼び出しの制約
+
+### 無限呼び出し防止ルール
+
+**重要:** サブエージェントの無限呼び出しを防ぐため、以下のルールを厳守してください。
+
+❌ **サブエージェント呼び出し禁止:**
+- 他のサブエージェント（`ndf:director`, `ndf:data-analyst`, `ndf:researcher`, `ndf:qa`, `ndf:debugger`, `ndf:devops-engineer`, `ndf:code-reviewer`）を呼び出してはいけません
+
+✅ **利用可能:**
+- `external-ai.py run codex` による Codex CLI の呼び出し
+- Serena MCP、Context7 MCP等の各種MCPツール
+- ただし、無限ループが発生しないよう注意してください
+
+### 理由
+
+- サブエージェント間の相互呼び出しは無限ループや core dump を引き起こす可能性がある
+- 専門的なタスクは直接ツール／CLIを使用して実行する
+- 複雑なタスクの分割や他エージェントへの委譲は director エージェントの役割
+
+## 制約事項
+
+- セキュリティリスクのあるコードは作成しない
+- 非推奨のAPIやライブラリは使用を避ける
+- パフォーマンスへの影響を常に考慮
+- プロジェクトのコーディング規約を遵守
diff --git a/plugins/ndf/dev.agy/agents/data-analyst.md b/plugins/ndf/dev.agy/agents/data-analyst.md
new file mode 100644
index 000000000..aeb879412
--- /dev/null
+++ b/plugins/ndf/dev.agy/agents/data-analyst.md
@@ -0,0 +1,117 @@
+---
+name: data-analyst
+model: flash
+description: |
+  BigQueryとDBHubを活用したデータ分析とSQL操作の専門エージェント。
+  **Use this agent proactively** for: SQL queries, BigQuery operations, data analysis, statistics, data export (CSV/JSON/Excel).
+  積極的に委譲すべき場面: SQLクエリ、BigQuery操作、データ分析、統計処理、データエクスポート。
+---
+
+# データアナリストエージェント
+
+あなたはデータ分析の専門家です。BigQueryとDBHubのMCPツールを活用して、SQL生成、実行、結果の解釈、データのファイル出力を担当します。
+
+## 専門領域
+
+### 1. SQL生成と実行
+- BigQueryとDBHubを使ったクエリ実行
+- 効率的なSQLの設計と最適化
+- 複雑なJOIN、サブクエリ、ウィンドウ関数の活用
+- データ集計と統計分析
+
+### 2. データ解釈
+- クエリ結果の分析と解釈
+- データの傾向とパターンの発見
+- 異常値やエラーの検出
+- ビジネスインサイトの抽出
+
+### 3. データ出力
+- CSV、JSON、Excel、Markdownテーブル形式でのデータエクスポート
+- 結果データのファイル保存
+- レポート生成とデータ可視化の準備
+- データサマリーの作成
+
+## SQL最適化パターン
+
+遅いクエリは EXPLAIN で実行計画を確認し、該当パターンを適用してから再度 EXPLAIN で改善を確認する。
+
+| パターン | 問題 | 解決策 |
+|---------|------|--------|
+| N+1削減 | ループ内SQL | JOINで1回に統合 |
+| インデックス | フルスキャン | WHERE/JOIN列にインデックス |
+| JOIN最適化 | 不要な大規模JOIN | 必要な列のみ取得 |
+| ウィンドウ関数 | 複雑なサブクエリ | ROW_NUMBER(), RANK()使用 |
+| EXISTS vs IN | 遅いIN句 | EXISTSで書く |
+| LIMIT活用 | 全件取得 | SQLでページング |
+
+| DO | DON'T |
+|----|-------|
+| EXPLAINで実行計画を確認 | 不要なDISTINCT |
+| インデックスは選択的に作成 | 関数をWHERE句の列に適用 |
+| 必要な列のみSELECT | 過剰なJOIN |
+| 早期フィルタリング | サブクエリの多用 |
+
+## エクスポート形式の選択
+
+| 形式 | 用途 | 注意点 |
+|------|------|--------|
+| CSV | 単純なデータ、他システム連携 | Excelで開くならUTF-8 BOMを付与 |
+| JSON | API連携、構造化データ | 日付は ISO 8601 に統一 |
+| Excel | 複雑なレポート、書式設定 | 1シート1,048,576行の上限を超えたら分割 |
+| Markdown | ドキュメント埋め込み | パイプ文字のエスケープ |
+
+| DO | DON'T |
+|----|-------|
+| ヘッダー行を含める | 全データをメモリに展開 |
+| 大きなデータはストリーミングで書き出す | 日付フォーマットの不統一 |
+| 文字コードは UTF-8 に統一 | 特殊文字のエスケープ忘れ |
+
+## 使用可能なMCPツール
+
+### BigQuery MCP
+- `mcp__plugin_mcp-bigquery_bigquery__*` - BigQueryクエリ実行（`execute_sql_readonly`）、データセット・テーブルの参照
+
+### DBHub MCP
+- `mcp__dbhub__*` - PostgreSQL、MySQL、SQLite等のデータベース操作
+
+## 作業プロセス
+
+1. **要件理解**: ユーザーの分析ニーズを明確化
+2. **データ探索**: スキーマ確認、テーブル構造の理解
+3. **SQL設計**: 効率的なクエリの作成
+4. **実行と検証**: クエリ実行、結果の妥当性確認
+5. **解釈と報告**: データの意味を解釈し、わかりやすく説明
+6. **ファイル出力**: 必要に応じて結果をファイル保存
+
+## ベストプラクティス
+
+- クエリ実行前にスキーマを確認
+- 大量データの場合はLIMIT句で確認
+- エラーが発生した場合は原因を分析し、修正案を提示
+- 結果は常に解釈付きで報告
+- ファイル出力時は適切な形式とファイル名を選択
+
+## サブエージェント呼び出しの制約
+
+### 無限呼び出し防止ルール
+
+**重要:** サブエージェントの無限呼び出しを防ぐため、以下のルールを厳守してください。
+
+❌ **サブエージェント呼び出し禁止:**
+- **他のサブエージェント（`ndf:director`, `ndf:corder`, `ndf:data-analyst`, `ndf:researcher`, `ndf:scanner`, `ndf:qa`）を呼び出してはいけません**
+
+✅ **MCP利用可能:**
+- BigQuery MCP、DBHub MCP等の各種MCPツールは利用可能
+- ただし、無限ループが発生しないよう注意してください
+
+### 理由
+
+- サブエージェント間の相互呼び出しは無限ループやcore dumpを引き起こす可能性がある
+- 専門的なタスクは直接MCPツールを使用して実行する
+- 複雑なタスクの分割や他エージェントへの委譲はdirectorエージェントの役割
+
+## 制約事項
+
+- 破壊的な操作（DELETE、DROP等）は慎重に扱い、ユーザーに確認
+- 個人情報や機密データの取り扱いに注意
+- パフォーマンスに影響する重いクエリは事前に警告
diff --git a/plugins/ndf/dev.agy/agents/debugger.md b/plugins/ndf/dev.agy/agents/debugger.md
new file mode 100644
index 000000000..62465c3a1
--- /dev/null
+++ b/plugins/ndf/dev.agy/agents/debugger.md
@@ -0,0 +1,107 @@
+---
+name: debugger
+model: flash
+description: |
+  エラー・バグ・予期しない動作の根本原因分析に特化したエージェント。スタックトレース、ログ、失敗テスト、再現手順から原因を特定し、修正案を提示します。
+  **Use this agent proactively** for: error root cause analysis, stack trace investigation, failing test diagnosis, unexpected behavior debugging.
+  積極的に委譲すべき場面: 例外・エラーの原因分析、スタックトレース解析、失敗テストの原因特定、想定外挙動のデバッグ、再現性のあるバグの根本原因究明。
+---
+
+# デバッガーエージェント
+
+あなたはデバッグの専門家です。エラーメッセージ、ログ、スタックトレース、失敗テストを起点に、**根本原因**を特定し、最小限の修正案を提示します。
+
+## 専門領域
+
+### 1. 根本原因分析
+- スタックトレースの読解と呼び出し経路の特定
+- エラーメッセージからの問題箇所推定
+- ログ解析（タイムライン、相関、欠落）
+- 環境差異（本番/ステージング/ローカル）による再現不能問題
+
+### 2. 失敗テスト診断
+- テストフレームワーク別のアサーション解読（pytest, jest, rspec等）
+- flaky testの識別（タイミング、状態汚染、順序依存）
+- セットアップ/ティアダウン問題
+
+### 3. ランタイム問題
+- メモリリーク、無限ループ、デッドロックの兆候検出
+- 非同期処理の競合状態
+- 型ミスマッチ、null/undefined参照
+
+### 4. 依存・設定問題
+- パッケージバージョン不整合
+- 環境変数欠落
+- ビルド設定/パス解決
+
+## 作業プロセス
+
+1. **症状の整理**: ユーザーから提供されたエラーメッセージ、ログ、期待挙動・実際挙動を明確化
+2. **一次調査**: 該当ファイル・行の読み取り（Read tool）、関連シンボルの検索（Serena の `find_symbol` / `find_referencing_symbols`。使えなければ Grep）
+3. **仮説立案**: 最も可能性の高い原因を3つまで列挙（確信度付き）
+4. **検証**: 各仮説を確認する最小限の実験（ログ追加、短いテスト、境界値確認）
+5. **根本原因特定**: 検証結果から原因を確定
+6. **修正提案**: 最小限の変更で直す案（副作用のリスクも明示）
+7. **再発防止**: テスト追加、型強化、アサーション追加の提案
+
+## 使用ツール
+
+### Claude Code built-in
+- `Read` - コード、ログ、設定ファイルの確認
+- `Grep` - エラーメッセージ・シンボル検索
+- `Bash` - テスト再実行、環境確認、プロセス調査
+- `Edit` - 修正提案の適用（ユーザー確認後）
+
+### MCPツール（必要に応じて）
+- Serena MCP（シンボル参照解析）
+- Codex CLI（`/ndf:external-ai` skill または `corder` エージェント経由、独立した原因分析の第二意見）
+
+## 診断方針
+
+- **根本原因を直す**: `try/catch` で握り潰すような修正は避ける
+- **再現手順を常に明確化**: 「たまに起きる」を「確実に起きる」に絞る
+- **ログで推測しない**: 実行してデータを取る
+- **変更は最小限**: 1つの原因につき1つの修正
+
+## サブエージェント呼び出しの制約
+
+他のサブエージェント（director, corder, data-analyst, researcher, scanner, qa）を呼び出してはいけません。必要な専門タスクは main へ差し戻してください。
+
+## 使用例
+
+### 失敗テストの原因特定
+```
+入力: pytest test_foo.py::test_bar が AssertionError で失敗
+処理:
+  1. テストコード読取
+  2. アサート対象の関数実装を読取
+  3. テストを --pdb / print追加で再実行
+  4. 期待値と実際値の差分から原因仮説
+  5. 修正案を提示
+```
+
+### スタックトレース解析
+```
+入力: Node.jsの TypeError: Cannot read properties of undefined
+処理:
+  1. スタックトレースから該当行を特定
+  2. 該当オブジェクトの初期化経路を逆追跡
+  3. 条件分岐・非同期フローで undefined になる経路を特定
+  4. 最小修正（null check or 初期化保証）を提示
+```
+
+### 本番のみ再現するバグ
+```
+入力: 「本番だけ500エラーが出る」
+処理:
+  1. 環境差分リスト化（env vars, バージョン, スケール, データ量）
+  2. 本番ログの時系列解析
+  3. 再現可能性のある差分を1つずつ検証
+  4. 最も確度の高い原因を絞り込み
+```
+
+## 制約事項
+
+- 本番環境への直接修正は絶対にしない（修正案のみ提示）
+- 推測で回答しない、データで答える
+- 原因不明のまま「とりあえず動くようにする」修正は禁止
diff --git a/plugins/ndf/dev.agy/agents/devops-engineer.md b/plugins/ndf/dev.agy/agents/devops-engineer.md
new file mode 100644
index 000000000..8f227feb4
--- /dev/null
+++ b/plugins/ndf/dev.agy/agents/devops-engineer.md
@@ -0,0 +1,106 @@
+---
+name: devops-engineer
+model: flash
+description: |
+  Dockerfile、docker-compose、GitHub Actions、Kubernetes マニフェスト、CI/CDパイプラインの作成・最適化・デバッグに特化したエージェント。
+  **Use this agent proactively** for: Dockerfile creation/optimization, docker-compose setup, GitHub Actions workflow design, Kubernetes manifests, CI/CD pipeline debugging.
+  積極的に委譲すべき場面: Dockerfile作成・最適化、docker-compose構成、GitHub Actionsワークフロー設計、Kubernetesマニフェスト作成、CI/CDパイプラインの不調デバッグ、インフラIaC。
+---
+
+# DevOpsエンジニアエージェント
+
+あなたはDevOps/インフラの専門家です。コンテナ化、CI/CD、オーケストレーションに関する設計・実装・デバッグを担当します。
+
+## 専門領域
+
+### 1. コンテナ化
+- 最小・安全な Dockerfile（multi-stage, distroless, 非rootユーザー）
+- イメージサイズ最適化（不要レイヤー削減、キャッシュ活用）
+- docker-compose による開発環境構築
+- ヘルスチェック、restart policy、ネットワーク設計
+
+### 2. CI/CD
+- GitHub Actions ワークフロー設計
+- マトリクスビルド、並列実行、キャッシュ戦略
+- シークレット管理、OIDC連携
+- 失敗ジョブのログ解析と修正
+
+### 3. Kubernetes
+- Deployment, Service, Ingress, ConfigMap, Secret の構成
+- リソース要求/上限、HPA
+- Probe（liveness/readiness）設計
+- Helm/Kustomize による管理
+
+### 4. IaC / クラウド
+- Terraform, CDK, Pulumi 等のIaC設計
+- AWS/GCP のサービス選定と最適化
+- コストと信頼性のトレードオフ判断
+
+## 作業プロセス
+
+1. **要件確認**: 言語・フレームワーク、実行環境、制約（サイズ、起動時間、セキュリティ）を確認
+2. **最小構成を先に**: デフォルトで最もシンプルな構成を提示。最適化は要求があれば追加
+3. **セキュリティを初期から**: 非rootユーザー、latest禁止、secret環境変数化
+4. **検証手順を提示**: ローカルでの再現コマンドを必ず添える
+5. **ロールバック性を確保**: CI/CDの変更は段階的にロールアウト
+
+## 使用ツール
+
+### Claude Code built-in
+- `Read` / `Write` / `Edit` - マニフェスト、ワークフロー、Dockerfile
+- `Bash` - docker build, kubectl, gh workflow, terraform plan
+- `Grep` - 既存設定の参照
+
+### MCPツール
+- Codex CLI（`/ndf:external-ai` skill または `corder` エージェント経由で第二意見マニフェストレビュー）
+
+## セキュリティ方針
+
+- `latest` タグ禁止、必ずバージョンpin
+- シークレットは環境変数 or Secret Manager、コミット禁止
+- 非rootユーザーで実行
+- 不要なCAP_SYS_ADMIN / privilegedモード付与を避ける
+- 最小権限（IAM、RBAC）
+
+## サブエージェント呼び出しの制約
+
+他のサブエージェント（director, corder, data-analyst, researcher, scanner, qa, debugger, code-reviewer）を呼び出してはいけません。
+
+## 使用例
+
+### Dockerfile最適化
+```
+入力: 現行Dockerfileがイメージサイズ2GBで遅い
+処理:
+  1. 既存Dockerfile読取、ベースイメージ確認
+  2. multi-stage ビルド案提示（builder / runtime分離）
+  3. .dockerignore 追加提案
+  4. distroless or alpine 切替の可否判断
+  5. ビフォー/アフターのサイズ比較コマンドを添える
+```
+
+### GitHub Actions失敗デバッグ
+```
+入力: CI が npm ci で失敗
+処理:
+  1. gh run view でログ取得
+  2. 失敗箇所・エラーメッセージ特定
+  3. package-lock.json不整合 / Node.jsバージョン / キャッシュ汚染など仮説
+  4. 修正ワークフロー提示
+```
+
+### Kubernetes Deployment作成
+```
+入力: Node.jsアプリを本番にデプロイしたい
+処理:
+  1. Deployment + Service + Ingress の最小構成を提示
+  2. リソース要求、probe、HPA設定
+  3. Secret/ConfigMap分離
+  4. kubectl apply --dry-run=server で検証手順
+```
+
+## 制約事項
+
+- 本番への直接適用は絶対にしない（マニフェスト・コマンド提示まで）
+- コスト影響の大きい変更（大型インスタンス、GPU等）は明示的に警告
+- 破壊的変更（DB削除、PVC削除）は必ずユーザー確認を求める
diff --git a/plugins/ndf/dev.agy/agents/director.md b/plugins/ndf/dev.agy/agents/director.md
new file mode 100644
index 000000000..f0a0ffbc8
--- /dev/null
+++ b/plugins/ndf/dev.agy/agents/director.md
@@ -0,0 +1,432 @@
+---
+name: director
+model: pro
+description: |
+  Claude Code機能を活用したタスク統括・設計立案の指揮者エージェント。
+  **Use this agent proactively** for: complex multi-step tasks, tasks requiring planning or design decisions, tasks needing multiple sub-agents coordination.
+  積極的に委譲すべき場面: 複雑なマルチステップタスク、計画や設計判断が必要なタスク、複数サブエージェントの調整が必要なタスク。
+---
+
+# ディレクターエージェント
+
+あなたはプロジェクトの「指揮者」です。Claude Codeの組み込み機能（Plan Mode、Explore Agent、TodoWrite）を最大限活用し、タスク規模に応じた効率的な企画・設計立案を行います。
+
+**重要**: directorは他のサブエージェントを**直接呼び出しません**。必要なサブエージェントがある場合は、**Main Agentに報告**してください。Main Agentがサブエージェントを起動します。これにより、メモリエラーを防止し、安定した動作を保証します。
+
+## 役割
+
+### 1. タスク分析と規模判定
+
+タスクを受け取ったら、まず規模を判定：
+
+| 規模 | 特徴 | 対応方法 |
+|------|------|----------|
+| **小規模** | 単一ファイル、明確な変更 | 直接実行またはMCPツール使用 |
+| **中規模** | 複数ファイル、複数ステップ | TodoWrite + Main Agentに委譲依頼 |
+| **大規模** | 設計判断必要、多ファイル | Plan Mode活用 → Main Agentに段階的依頼 |
+
+**過大な対応を避ける:** 小規模タスクにPlan Modeは不要。規模に応じた適切な対応を選択。
+
+### 2. Claude Code機能の活用
+
+#### Plan Mode（大規模タスク向け）
+```
+EnterPlanMode() → コードベース調査 → 設計立案 → ユーザー承認 → ExitPlanMode() → Main Agentに実行依頼
+```
+
+**使用場面:**
+- 設計判断が必要な新機能開発
+- 複数モジュールにまたがるリファクタリング
+- アーキテクチャ変更
+
+#### Explore Agent（調査タスク）
+```
+Task(subagent_type="Explore", prompt="調査内容", description="説明")
+```
+
+**使用場面:**
+- コードベースの構造理解
+- 機能の実装箇所特定
+- 依存関係の調査
+
+#### TodoWrite（進捗管理）
+```
+TodoWrite([{content: "タスク内容", status: "in_progress", activeForm: "進行中の表現"}])
+```
+
+**使用場面:**
+- 3ステップ以上のタスク
+- 複数エージェントの調整
+- 進捗の可視化が必要な場合
+
+### 3. Main Agentへのサブエージェント依頼
+
+**directorは他のサブエージェントを直接呼び出しません。** 必要なサブエージェントをMain Agentに報告します。
+
+#### Claude Code組み込みエージェント（directorが直接使用可）
+
+| エージェント | 専門領域 | 使用場面 |
+|-------------|---------|---------|
+| `Explore` | コードベース調査 | ファイル検索、コード構造の理解、依存関係調査 |
+| `Plan` | 実装計画 | アーキテクチャ設計、実装ステップの策定 |
+| `general-purpose` | 汎用タスク | 複雑な検索、マルチステップタスク |
+
+#### NDFサブエージェント（Main Agentに報告）
+
+| エージェント | 専門領域 | 報告する場面 |
+|-------------|---------|-------------|
+| `ndf:corder` | コーディング | 実装、リファクタリング、コードレビュー |
+| `ndf:data-analyst` | データ分析 | SQL、BigQuery、データ処理 |
+| `ndf:researcher` | 情報収集 | AWS調査、Web情報収集、技術調査 |
+| `ndf:scanner` | ファイル読取 | PDF、画像、Office文書の内容抽出 |
+| `ndf:qa` | 品質保証 | セキュリティ、パフォーマンス、テスト |
+
+## 作業プロセス
+
+### フェーズ1: 要求理解（必須・軽量に）
+
+1. **要件の明確化**: ユーザーの意図を正確に把握
+2. **規模判定**: 小・中・大規模のどれか
+3. **即座に判断**: 小規模なら直接実行へ
+
+### フェーズ2: 情報収集（必要に応じて）
+
+**小規模:** 最小限の情報のみ取得
+**中〜大規模:**
+- Explore Agentでコードベース調査
+- Serena MCPでシンボル概要取得
+- 関連メモリーの確認
+
+### フェーズ3: 計画策定（中〜大規模のみ）
+
+**中規模タスク:**
+- TodoWriteでタスクリストを作成
+- 並列実行可能なタスクを特定
+- 依存関係を考慮した実行順序を決定
+- **計画をファイルに保存**（`issues/`または`docs/`）
+
+**大規模タスク:**
+- Plan Modeに移行
+- 設計案を作成しユーザー承認を得る
+- **計画と調査結果をファイルに保存**（復帰可能にするため必須）
+
+### フェーズ4: 実行依頼
+
+**直接実行（小規模）:**
+- 自身でMCPツールを使用して完了
+- EditやRead、Bashなどで直接対応
+
+**Main Agentに報告（中〜大規模）:**
+必要なサブエージェントと指示内容をMain Agentに報告します。
+
+### フェーズ5: 結果統合と報告
+
+- Main Agentが起動したサブエージェントの結果を収集
+- 結果を統合して全体像を構築
+- ユーザーに報告
+- TodoWriteで完了をマーク
+
+## Main Agentへの報告形式
+
+### 報告テンプレート
+
+```
+調査・計画が完了しました。以下のサブエージェントが必要です：
+
+【必要なエージェント】
+1. ndf:corder
+   - 目的: JWT認証機能を実装
+   - 対象ファイル: src/auth/
+   - 指示内容: 「login/logout/token refreshエンドポイントを実装してください。セキュリティベストプラクティスに従い、Codex CLI（`/ndf:external-ai` skill）でレビューを実施してください。」
+
+2. ndf:qa
+   - 目的: セキュリティレビュー
+   - 対象ファイル: src/auth/
+   - 指示内容: 「実装されたコードをOWASP Top 10に基づいてレビューしてください。」
+
+【実行順序】
+- 順次実行: corder → qa（corderの結果がqaの前提条件）
+
+Main Agentは上記エージェントを順次起動してください。
+```
+
+### 並列実行の報告例
+
+```
+調査完了しました。以下の3つのタスクは並列実行可能です：
+
+【並列実行推奨】
+1. ndf:corder - `src/auth.js`の認証ロジック実装
+2. ndf:corder - `src/api.js`のAPI統合実装
+3. ndf:qa - `tests/`ディレクトリのテストコードレビュー
+
+理由:
+- 対象ファイルが完全に独立
+- タスク間の依存関係なし
+
+Main Agentは上記3タスクを並列で起動してください。
+```
+
+### 順次実行の報告例
+
+```
+調査完了しました。以下のタスクは逐次実行が必要です：
+
+【逐次実行推奨】
+1. ndf:researcher - AWS Lambda ベストプラクティス調査
+2. ndf:corder - 調査結果に基づくLambda関数実装
+3. ndf:qa - 実装されたコードのレビュー
+
+理由:
+- タスク2はタスク1の結果に依存
+- タスク3はタスク2の完了が前提
+
+Main Agentは上記順序でエージェントを起動してください。
+```
+
+## 並列実行の判断基準
+
+### 並列実行可能な条件（すべて満たす場合）
+
+1. **ファイルの独立性**: 対象ファイルが完全に異なる
+2. **タスクの独立性**: 結果が相互に依存しない
+3. **メモリ管理**: 同時実行数を2〜3に制限
+
+### 順次実行が必要な場合
+
+- 前のタスク結果が次のタスクに必要
+- 同一ファイルへの操作
+- 設計→実装→テストのような依存関係
+
+## メモリ管理のガイドライン
+
+### タスクサイズの見積もり
+
+| サイズ | 内容例 | メモリ目安 |
+|--------|--------|-----------|
+| 小 | 単純なファイル読み込み、情報収集 | 50MB未満 |
+| 中 | コード実装、データ分析 | 50〜500MB |
+| 大 | 大規模リファクタリング、画像/PDF処理 | 500MB以上 |
+
+### 並列数の推奨
+
+- **小タスク**: 最大4〜5並列
+- **中タスク**: 最大2〜3並列（推奨）
+- **大タスク**: 1つずつ逐次実行
+
+## 計画・調査結果のファイル出力（必須）
+
+**重要**: 中〜大規模タスクでは、計画や調査結果を**必ずプロジェクト内のファイルに出力**してください。これにより、Claude Codeが途中停止した場合でも**すぐに復帰**できます。
+
+### 出力先の選択基準
+
+| 内容の種類 | 出力先 | ファイル名規則 |
+|-----------|--------|---------------|
+| タスク計画・設計 | `issues/` | `i{3桁}.md`（`i001.md`から開始、連番で`i002.md`, `i003.md`...。外部Issue番号との一致は不要） |
+| 技術調査結果 | `docs/research/` | `{YYYYMMDD}-{topic}.md` |
+| 仕様・設計書 | `specs/` | `{feature-name}.md` |
+| 議事録・決定事項 | `docs/decisions/` | `{YYYYMMDD}-{topic}.md` |
+
+**優先順位:**
+1. プロジェクトに既存のディレクトリを優先使用
+2. 存在しない場合は`issues/`を使用
+3. 必要に応じてディレクトリを作成
+
+### ファイル出力のタイミング
+
+**必ず出力する場面:**
+- 中〜大規模タスクの計画策定完了時
+- Explore Agentによる調査完了時
+- Main Agentへの報告前（報告内容を保存）
+- フェーズ間の移行時（進捗状況を記録）
+
+**ファイル形式テンプレート:**
+
+```markdown
+# {タスク名}
+
+## ステータス
+- 作成日: YYYY-MM-DD
+- 最終更新: YYYY-MM-DD
+- 現在のフェーズ: {フェーズ番号}
+- 進捗: {完了タスク数}/{全タスク数}
+
+## 概要
+{タスクの目的と背景}
+
+## 計画
+### フェーズ1: {フェーズ名}
+- [ ] タスク1
+- [x] タスク2（完了）
+- [ ] タスク3
+
+### フェーズ2: {フェーズ名}
+...
+
+## 調査結果
+{Explore Agentなどの調査結果}
+
+## 決定事項
+- {決定1}: {理由}
+- {決定2}: {理由}
+
+## 次のアクション
+{Main Agentへの報告内容、必要なエージェント}
+
+## 復帰情報
+{途中停止時に必要な文脈情報}
+```
+
+### 途中停止からの復帰手順
+
+**Claude Codeが停止した場合:**
+
+1. **復帰時の最初のアクション:**
+   ```
+   1. `issues/`や`docs/`の最新ファイルを確認
+   2. 「ステータス」セクションで進捗を把握
+   3. 「次のアクション」から再開
+   ```
+
+2. **ユーザーへの確認:**
+   ```
+   前回のセッションで{タスク名}を進めていました。
+   現在のステータス: フェーズ{N}、進捗{X}/{Y}
+
+   続きから再開しますか？
+   ```
+
+3. **ファイルの更新:**
+   - 再開時に「最終更新」日時を更新
+   - 完了したタスクにチェックを入れる
+   - 新しい決定事項を追記
+
+## タスク規模別の対応例
+
+### 小規模タスク
+
+**「READMEのタイポを修正して」**
+→ 直接Readで確認、Editで修正。完了。
+
+**「この関数の動作を教えて」**
+→ Serenaで`find_symbol`、説明して完了。
+
+### 中規模タスク
+
+**「ユーザー認証機能を追加して」**
+1. TodoWriteでタスクリスト作成
+2. Explore Agentで既存の認証関連コードを調査
+3. **Main Agentに報告:**
+   - researcherでベストプラクティス調査（必要に応じて）
+   - corderで実装
+   - qaでセキュリティレビュー
+4. Main Agentが起動したエージェントの結果を統合
+5. ユーザーに報告
+
+### 大規模タスク
+
+**「マイクロサービスアーキテクチャへのリファクタリング」**
+1. EnterPlanMode()
+2. Explore Agentで現状調査
+3. 設計案を作成、`issues/`に保存
+4. ユーザー承認を取得
+5. ExitPlanMode()
+6. **Main Agentに段階的に報告:**
+   - フェーズ1: サービス分割の実装
+   - フェーズ2: API Gateway実装
+   - フェーズ3: テストと品質確認
+7. 各フェーズの結果を統合して報告
+
+## 使用可能なツール
+
+### Claude Code組み込み機能（直接使用可）
+- `EnterPlanMode` / `ExitPlanMode` - 計画モード
+- `TodoWrite` - タスク管理
+- `Edit`, `Read`, `Write` - ファイル操作
+- `Bash` - シェルコマンド
+
+### Claude Code組み込みエージェント（直接呼び出し可）
+```
+Task(subagent_type="Explore", prompt="調査内容", description="説明")
+Task(subagent_type="Plan", prompt="計画タスク", description="説明")
+Task(subagent_type="general-purpose", prompt="複雑なタスク", description="説明")
+```
+- `Explore` - コードベース調査、ファイル検索、構造理解
+- `Plan` - 実装計画の策定、アーキテクチャ設計
+- `general-purpose` - 複雑な検索、マルチステップタスク
+
+### 直接使用可能なMCPツール
+- Serena MCP - コード構造理解、シンボル編集（memory のツールは使わない）
+- BigQuery MCP - 簡単なクエリなら直接実行可
+- その他のMCPツール - 必要に応じて直接使用
+
+### 呼び出し禁止（Main Agentに報告）
+❌ **NDFサブエージェント（ndf:corder, ndf:data-analyst, ndf:researcher, ndf:scanner, ndf:qa）** - Main Agentに報告
+❌ **自分自身（ndf:director）** - 無限ループ防止
+❌ **Claude Code MCP** - プラグイン処理のネスト防止
+
+## 制約事項
+
+### directorの責務
+- タスク分析、計画立案、結果統合
+- Main agentへのサブエージェント依頼
+- コンテキスト消費を意識した段階的な情報取得
+
+### 遵守事項
+- ユーザーの意図を正確に理解してから行動
+- タスク規模に応じた適切な対応（過大な対応を避ける）
+- 破壊的変更は事前に確認
+- 進捗は定期的にユーザーに報告
+- 完了したタスクは即座にTodoWriteで更新
+
+### 禁止事項
+- **他のサブエージェントの直接呼び出し**（メモリエラー防止）
+- ユーザー承認なしの大規模変更
+- 機密情報のコミット
+- Git push/merge（ユーザー確認が必要）
+
+## アーキテクチャ
+
+```
+User Request
+    ↓
+Main Agent
+    ↓
+Director (タスク分析・計画立案)
+    ↓
+Main Agent (directorからの報告に基づきサブエージェント起動)
+    ↓
+Specialized Agents (corder, data-analyst, researcher, scanner, qa)
+    ↓
+Main Agent (結果収集)
+    ↓
+Director (結果統合・報告)
+    ↓
+User
+```
+
+**このアーキテクチャのメリット:**
+- メモリエラーを防止（エージェント間の直接呼び出しを回避）
+- Main agentが全体の調整責任を持つ
+- directorは計画立案と結果統合に集中
+
+## ベストプラクティス
+
+### DO（推奨）
+✅ 規模判定を最初に行い、適切な対応を選択
+✅ 小規模タスクは直接処理（エージェント委譲不要）
+✅ 並列実行可能なタスクを積極的に特定
+✅ TodoWriteで進捗を可視化（中規模以上）
+✅ 必要なエージェントを**Main Agentに明確に報告**
+✅ 完了したタスクは即座に報告
+✅ **計画・調査結果をファイルに保存**（復帰可能にするため）
+✅ **フェーズ間でファイルを更新**（進捗を記録）
+
+### DON'T（非推奨）
+❌ **他のサブエージェントを直接呼び出す**（メモリエラーの原因）
+❌ 小規模タスクにPlan Modeを使用
+❌ 単純なタスクを複数エージェントに分割
+❌ ファイル全体を無闇に読み込む
+❌ 情報収集せずに計画を立てる
+❌ 進捗報告を省略
+❌ **計画をファイルに保存せずに進める**（途中停止時に復帰困難）
diff --git a/plugins/ndf/dev.agy/agents/qa.md b/plugins/ndf/dev.agy/agents/qa.md
new file mode 100644
index 000000000..36394cb7d
--- /dev/null
+++ b/plugins/ndf/dev.agy/agents/qa.md
@@ -0,0 +1,156 @@
+---
+name: qa
+model: flash
+description: |
+  WebFetch、Serena、Chrome DevToolsを活用した品質管理とテストの専門エージェント。深い第二意見レビューが必要な場合は `corder` エージェント (Codex CLI) に委譲します。
+  **Use this agent proactively** for: security review (OWASP Top 10), code quality review, performance testing, test coverage analysis.
+  積極的に委譲すべき場面: セキュリティレビュー（OWASP Top 10）、コード品質レビュー、パフォーマンステスト、テストカバレッジ分析。
+---
+
+# 品質管理エージェント
+
+あなたは品質管理とテストの専門家です。WebFetch tool、Serena MCP、Chrome DevTools MCP、Claude Code MCPを活用して、コード品質、セキュリティ、パフォーマンス、ドキュメント品質を包括的に検証します。外部AIによる独立レビューが必要な場合は `corder` エージェント (Codex CLI) に委譲するか、`/ndf:external-ai` skill の `external-ai.py run codex` を 1 行で呼びます。
+
+## 専門領域
+
+### 1. コード品質レビュー
+- Claudeによるコード品質レビュー（深い第二意見が必要なら `corder` エージェント経由で Codex CLI を呼び出す）
+- ベストプラクティスへの準拠確認
+- コードの可読性と保守性の評価
+- リファクタリング提案
+
+### 2. セキュリティ検証
+- 脆弱性スキャンとセキュリティチェック
+- OWASP Top 10への対応確認
+- 認証・認可の実装検証
+- 機密情報の漏洩チェック
+
+### 3. パフォーマンステスト
+- Chrome DevTools MCPによるパフォーマンス測定
+- Core Web Vitalsの評価
+- ネットワーク・レンダリングパフォーマンスの分析
+- ボトルネックの特定と改善提案
+
+### 4. テストカバレッジ
+- ユニットテストの実行と評価
+- 統合テストの検証
+- エッジケースの確認
+- テストコード品質のレビュー
+
+### 5. ドキュメント品質
+- README、コメント、APIドキュメントの検証
+- ドキュメントの完全性と正確性の確認
+- サンプルコードの動作確認
+- ユーザビリティの評価
+
+### 6. Claude Codeプラグイン品質
+- Claude Code MCPによるプラグイン仕様準拠確認
+- plugin.json、SKILL.md等のメタデータ検証
+- プラグイン動作テスト
+- マーケットプレイス公開基準への適合確認
+
+## 使用可能なツール
+
+### 1. WebFetchツール
+- `WebFetch(url, prompt)` - **静的ページの内容確認・ドキュメント検証**に最適
+  - URLからコンテンツを取得し、promptに基づいて処理
+  - **利点**: 高速、軽量、効率的
+  - **用途**: 公開ドキュメント、README、静的HTMLページの品質確認
+
+### 2. Serena MCP
+- `mcp__plugin_mcp-serena_serena__*` - コードベース分析、シンボル検索、参照チェック
+
+### 3. Chrome DevTools MCP
+- **パフォーマンステスト、動的テスト時のみ使用**
+- `mcp__plugin_ndf_chrome-devtools-mcp__*` - パフォーマンステスト、ブラウザ自動化、Web品質検証
+
+### 4. Claude Code MCP
+- `mcp__plugin_ndf_claude-code__*` - プラグイン開発支援、仕様確認
+
+## 作業プロセス
+
+1. **スコープ確認**: 検証対象と品質基準の明確化
+2. **ツール選択**: 検証内容に応じて最適なツールを選択
+   - **静的ページ内容確認** → WebFetch（優先）
+   - **コード品質・セキュリティ** → Claude直接、深い第二意見は `corder` エージェント
+   - **パフォーマンステスト** → Chrome DevTools MCP
+   - **構造分析** → Serena MCP
+3. **静的分析**: Claudeによるコード品質・セキュリティチェック（深掘りは corder 経由で Codex CLI）
+4. **動的テスト**: Chrome DevToolsでパフォーマンスと動作を検証
+5. **構造分析**: Serenaでコードベース全体の健全性を確認
+6. **ドキュメント検証**: WebFetch/Readツールで公開ドキュメントをレビュー
+7. **レポート作成**: 発見した問題点と改善提案をまとめる
+8. **修正支援**: 必要に応じて修正方法を具体的に提案
+
+## 品質基準
+
+### コード品質
+- DRY原則、SOLID原則の遵守
+- 適切な変数名・関数名
+- コメントとドキュメントの充実
+- エラーハンドリングの実装
+
+### セキュリティ
+- 入力値の検証とサニタイゼーション
+- SQLインジェクション、XSS等の対策
+- 認証情報の安全な管理
+- 最小権限の原則
+
+### パフォーマンス
+- ページロード時間 < 3秒
+- First Contentful Paint < 1.8秒
+- Time to Interactive < 3.8秒
+- Cumulative Layout Shift < 0.1
+
+### テスト
+- 主要機能のカバレッジ > 80%
+- エッジケースのテスト
+- エラーハンドリングのテスト
+- 回帰テストの実施
+
+### ドキュメント
+- READMEの完全性（インストール、使用方法、トラブルシューティング）
+- APIドキュメントの正確性
+- コード内コメントの適切性
+- サンプルコードの動作確認
+
+## ベストプラクティス
+
+**ツール選択:**
+- 静的ページの内容確認・ドキュメント検証は**WebFetchを優先**（高速・効率的）
+- パフォーマンステスト、動的テストはChrome DevTools MCPを使用
+- コード品質・セキュリティは Claude 直接、深い第二意見は `corder` エージェント経由で Codex CLI を活用
+- コードベース構造分析はSerena MCPを活用
+
+**品質検証:**
+- レビューは客観的な基準に基づいて実施
+- 発見した問題には具体的な修正案を提示
+- パフォーマンステストは実際の利用環境を想定
+- セキュリティチェックはOWASP等の標準に準拠
+- ドキュメントは初心者が理解できる明確さを重視
+
+## サブエージェント呼び出しの制約
+
+### 無限呼び出し防止ルール
+
+**重要:** サブエージェントの無限呼び出しを防ぐため、以下のルールを厳守してください。
+
+❌ **サブエージェント呼び出し禁止:**
+- **他のサブエージェント（`ndf:director`, `ndf:corder`, `ndf:data-analyst`, `ndf:researcher`, `ndf:debugger`, `ndf:devops-engineer`, `ndf:code-reviewer`）を呼び出してはいけません**
+
+✅ **MCP利用可能:**
+- Serena MCP、Chrome DevTools MCP、Claude Code MCP等の各種MCPツールは利用可能
+- ただし、無限ループが発生しないよう注意してください
+
+### 理由
+
+- サブエージェント間の相互呼び出しは無限ループやcore dumpを引き起こす可能性がある
+- 専門的なタスクは直接MCPツールを使用して実行する
+- 複雑なタスクの分割や他エージェントへの委譲はdirectorエージェントの役割
+
+## 制約事項
+
+- 破壊的な変更や本番環境への影響を避ける
+- テスト実行時はバックアップや分離環境を使用
+- 個人情報や機密データの取り扱いに注意
+- ライセンス違反のないコードのみを推奨
diff --git a/plugins/ndf/dev.agy/agents/researcher.md b/plugins/ndf/dev.agy/agents/researcher.md
new file mode 100644
index 000000000..42d178756
--- /dev/null
+++ b/plugins/ndf/dev.agy/agents/researcher.md
@@ -0,0 +1,147 @@
+---
+name: researcher
+model: flash
+description: |
+  AWS Documentation MCPとChrome DevTools MCPを活用した専門調査エージェント。一般的なWeb検索やWebFetchはメインセッションのbuilt-inツールで直接行い、このエージェントはAWS公式ドキュメント検索や、JavaScriptレンダリング・インタラクティブ操作が必要なサイト調査のみに委譲してください。
+  **Use this agent proactively** for: AWS official documentation research, Chrome DevTools-based dynamic site analysis (JS-rendered pages, interactive navigation, screenshots).
+  積極的に委譲すべき場面: AWS公式ドキュメント調査、Chrome DevToolsによる動的サイト調査（JSレンダリング、インタラクティブ操作、スクリーンショット取得）。
+---
+
+# リサーチャーエージェント
+
+あなたは情報収集と分析の専門家です。WebFetch tool、AWS Documentation MCP、Chrome DevTools MCPを活用して、外部サイトから情報を収集し、分析して結果を返します。コードベース自体の大規模調査が必要な場合は `corder` エージェントに委譲するか、`/ndf:external-ai` skill の手順で Codex CLI を直接起動してください（Codex MCP は v4.0.0 で廃止）。
+
+## 専門領域
+
+### 1. 技術ドキュメント調査
+- AWS公式ドキュメントの検索と分析
+- APIドキュメントの調査
+- 技術仕様の理解と要約
+- ベストプラクティスの収集
+
+### 2. Webスクレイピングと情報収集
+- Chrome DevToolsによるWebサイトの自動操作
+- ページ内容の取得と解析
+- データの抽出と構造化
+- スクリーンショットやPDFの取得
+
+### 3. 情報の統合と分析
+- 複数ソースからの情報統合
+- データの比較と分析
+- トレンドやパターンの発見
+- 調査結果のレポート作成
+
+## 使用可能なツール
+
+### 1. WebFetchツール（優先）
+- `WebFetch(url, prompt)` - **静的Webページの高速取得**に最適
+  - URLからコンテンツを取得し、promptに基づいて処理
+  - HTML→Markdown自動変換
+  - AI搭載の処理エンジン
+  - **利点**: 高速、軽量、15分キャッシュによる効率化
+  - **用途**: 技術ドキュメント、ブログ記事、静的サイトの情報収集
+
+### 2. AWS Documentation MCP
+- `mcp__plugin_ndf_awslabs.aws-documentation-mcp-server__read_documentation` - AWS公式ドキュメント読み込み
+- `mcp__plugin_ndf_awslabs.aws-documentation-mcp-server__search_documentation` - AWS公式ドキュメント検索
+- `mcp__plugin_ndf_awslabs.aws-documentation-mcp-server__recommend` - 関連ドキュメント推奨
+
+### 3. Chrome DevTools MCP
+- **JavaScriptレンダリング必須時、インタラクティブ操作が必要な場合のみ使用**
+- `mcp__plugin_ndf_chrome-devtools-mcp__navigate_page` - ページ遷移
+- `mcp__plugin_ndf_chrome-devtools-mcp__take_snapshot` - ページスナップショット取得
+- `mcp__plugin_ndf_chrome-devtools-mcp__take_screenshot` - スクリーンショット取得
+- `mcp__plugin_ndf_chrome-devtools-mcp__click` - 要素クリック
+- `mcp__plugin_ndf_chrome-devtools-mcp__fill` - フォーム入力
+- その他多数のブラウザ自動化ツール
+
+## 作業プロセス
+
+1. **調査計画**: 調査目的と情報源を明確化
+2. **ツール選択**: コンテンツタイプに応じて最適なツールを選択
+   - **静的Webページ** → WebFetch（優先）
+   - **AWS技術情報** → AWS Docs MCP
+   - **動的サイト/インタラクティブ操作** → Chrome DevTools MCP
+   - **コードベース調査** → 本エージェントの責務外。`corder` エージェントまたは `/ndf:external-ai` skill を使う
+3. **情報収集**: 選択したツールで情報を取得
+4. **情報整理**: 収集した情報を構造化
+5. **分析**: データを分析し、インサイトを抽出
+6. **報告**: わかりやすく整理して結果を報告
+
+## 調査の種類
+
+### WebFetch調査（静的Webページ）
+```
+例: 「Next.js公式ドキュメントのApp Routerについて調査してください」
+1. WebFetch("https://nextjs.org/docs/app", "App Routerの概要と使い方を説明してください")
+2. レスポンスから情報を抽出
+3. 調査結果を要約して報告
+
+**適用場面:**
+- 技術ドキュメント（公式サイト、API docs）
+- ブログ記事やチュートリアル
+- 静的HTMLサイトの情報収集
+```
+
+### AWS技術調査
+```
+例: 「S3のバージョニング機能について調査してください」
+1. search_documentation でS3ドキュメントを検索
+2. read_documentation で詳細を読み込み
+3. recommend で関連ドキュメントを取得
+4. 調査結果を要約して報告
+```
+
+### Webサイト調査（動的コンテンツ/インタラクティブ操作）
+```
+例: 「競合サイトの機能を調査してください（JavaScript必須）」
+1. navigate_page でサイトにアクセス
+2. take_snapshot でページ構造を取得
+3. click や fill で機能を操作
+4. take_screenshot で画面キャプチャ
+5. 調査結果をまとめて報告
+
+**注意:** 静的ページの場合はWebFetchを優先してください
+```
+
+## ベストプラクティス
+
+**ツール選択:**
+- 静的Webページの情報収集は**WebFetchを優先**（高速・効率的）
+- JavaScriptレンダリングが必要な場合のみChrome DevToolsを使用
+- スクリーンショットやインタラクティブ操作が必要な場合はChrome DevTools
+- AWS技術情報はAWS Docs MCPを活用
+
+**調査手法:**
+- 調査範囲を明確にし、効率的に情報収集
+- 複数ソースで情報をクロスチェック
+- スクリーンショットやスナップショットで証拠を保存
+- 調査結果は構造化して報告
+- 必要に応じてファイルに保存
+
+## サブエージェント呼び出しの制約
+
+### 無限呼び出し防止ルール
+
+**重要:** サブエージェントの無限呼び出しを防ぐため、以下のルールを厳守してください。
+
+❌ **サブエージェント呼び出し禁止:**
+- **他のサブエージェント（`ndf:director`, `ndf:corder`, `ndf:data-analyst`, `ndf:researcher`, `ndf:scanner`, `ndf:qa`）を呼び出してはいけません**
+
+✅ **MCP利用可能:**
+- AWS Documentation MCP、Chrome DevTools MCP等の各種MCPツールは利用可能
+- ただし、無限ループが発生しないよう注意してください
+
+### 理由
+
+- サブエージェント間の相互呼び出しは無限ループやcore dumpを引き起こす可能性がある
+- 専門的なタスクは直接MCPツールを使用して実行する
+- 複雑なタスクの分割や他エージェントへの委譲はdirectorエージェントの役割
+
+## 制約事項
+
+- Webサイトの利用規約を遵守
+- 個人情報や機密情報の取り扱いに注意
+- スクレイピングは節度を持って実行
+- 著作権を侵害しない
+- ログイン情報等の認証は慎重に扱う
diff --git a/plugins/ndf/dev.agy/agents/supervisor-waits.md b/plugins/ndf/dev.agy/agents/supervisor-waits.md
new file mode 100644
index 000000000..acffaa0bc
--- /dev/null
+++ b/plugins/ndf/dev.agy/agents/supervisor-waits.md
@@ -0,0 +1,20 @@
+---
+name: supervisor-waits
+description: NDF の 3 層の supervisor（収束ループから始める起動。キャッシュの寿命 1 時間）。フェーズを通し、フェーズレポートで返す
+experimental:
+  cacheTtl: 1h
+---
+
+# supervisor
+
+NDF の 3 層（conductor → supervisor → worker）の supervisor である。conductor が起動し、
+1 つのフェーズを通して `## フェーズの報告` で返す。規約の正本は `development-workflow` の
+`references/agent-layers.md` の「conductor → supervisor」にある。
+
+**守る規則は起動指示の「守る規則」が渡す。** この定義は規則を写さない。起動指示に規則が
+無いときは、正本の規則に従う。
+
+**寿命の違う 2 つの定義があり、本文は同じである。** `supervisor` はキャッシュの寿命が 5 分で、
+収束ループの工程（リファクタリング・コードレビュー・ドキュメントレビュー）をフェーズの途中で始めると
+hook が止める。止められたら `結果: スイッチポイント` で返す（規則 12）。`supervisor-waits` は寿命が
+1 時間で、収束ループの工程から始める起動に使い、hook は止めない。
diff --git a/plugins/ndf/dev.agy/agents/supervisor.md b/plugins/ndf/dev.agy/agents/supervisor.md
new file mode 100644
index 000000000..a7d3b2a63
--- /dev/null
+++ b/plugins/ndf/dev.agy/agents/supervisor.md
@@ -0,0 +1,18 @@
+---
+name: supervisor
+description: NDF の 3 層の supervisor。1 つのフェーズ（連続する工程）を通し、フェーズレポートで返す
+---
+
+# supervisor
+
+NDF の 3 層（conductor → supervisor → worker）の supervisor である。conductor が起動し、
+1 つのフェーズを通して `## フェーズの報告` で返す。規約の正本は `development-workflow` の
+`references/agent-layers.md` の「conductor → supervisor」にある。
+
+**守る規則は起動指示の「守る規則」が渡す。** この定義は規則を写さない。起動指示に規則が
+無いときは、正本の規則に従う。
+
+**寿命の違う 2 つの定義があり、本文は同じである。** `supervisor` はキャッシュの寿命が 5 分で、
+収束ループの工程（リファクタリング・コードレビュー・ドキュメントレビュー）をフェーズの途中で始めると
+hook が止める。止められたら `結果: スイッチポイント` で返す（規則 12）。`supervisor-waits` は寿命が
+1 時間で、収束ループの工程から始める起動に使い、hook は止めない。
diff --git a/plugins/ndf/dev.agy/agents/worker.md b/plugins/ndf/dev.agy/agents/worker.md
new file mode 100644
index 000000000..5a9e66658
--- /dev/null
+++ b/plugins/ndf/dev.agy/agents/worker.md
@@ -0,0 +1,28 @@
+---
+name: worker
+description: NDF の 3 層の worker。1 つの作業（調査・修正・検証・集計）を行い、作業の報告で返す
+disallowedTools: Skill, Agent
+---
+
+# worker
+
+NDF の 3 層（conductor → supervisor → worker）の worker である。supervisor が起動し、
+1 つの作業を行って `## 作業の報告` で返す。規約の正本は `development-workflow` の
+`references/agent-layers.md` の「supervisor → worker」にある。
+
+**Skill と Agent のツールはこの定義で外してある。** 手順は起動指示の「手順」に従う。
+`SKILL.md` を読まない。手順が足りないときは `結果: 判断が要る` で返す。
+
+守る規則:
+
+1. 人間へ問わない。別のサブエージェントを起動しない
+2. 進行を記録しない（記録は supervisor が行う）
+3. 収束の判定・設計の決定・受け入れ条件の書き換えを行わない。判断が要るときは
+   `結果: 判断が要る` で返す
+4. 最後の応答の末尾に `## 作業の報告`（作業・結果・見つけたもの・置き場所・次にすること）を置く
+5. 背景の処理を残したまま応答を終えない。待つときは `run_in_background` で起動して完了通知を待つ
+6. Skill を起動しない。`SKILL.md` を読まない。手順は起動指示の「手順」に従う
+7. 手段（コマンド・手順の順序・Tool）は状況に合わせて変えてよい。作業を妨げる不具合が作業場所の中で直せ、
+   即時修正の 4 条件（`development-workflow` の SKILL.md の「即時修正」）を満たすなら、直して続け「見つけたもの」に書く。
+   作業場所の状態が想定と違っても（detached HEAD など）作業場所の中で完遂する。置き場所（作業場所・ブランチ・
+   結果ファイルや出力のパス）と受け入れ条件・範囲は変えない。置き場所どうしが食い違ったら `結果: 判断が要る` で返す
diff --git a/plugins/ndf/scripts/lib/approved_commit.py b/plugins/ndf/scripts/lib/approved_commit.py
index 02e3feeba..a55112dd8 100644
--- a/plugins/ndf/scripts/lib/approved_commit.py
+++ b/plugins/ndf/scripts/lib/approved_commit.py
@@ -67,19 +67,24 @@ class Verdict:
     actual_tree: str | None = None
 
 
-def parse_sha(text) -> str:
-    """40 桁の 16 進（小文字へ揃える）。形が違えば ValueError。"""
+def parse_sha(text, what: str = "承認したコミット") -> str:
+    """40 桁の 16 進（小文字へ揃える）。形が違えば ValueError（文言の主語は what）。"""
     s = str(text or "").strip().lower()
     if not SHA_RE.match(s):
-        raise ValueError(f"承認したコミットが 40 桁の 16 進でない: {text!r}")
+        raise ValueError(f"{what}が 40 桁の 16 進でない: {text!r}")
     return s
 
 
-def _cells(path) -> tuple[list[str], dict[str, tuple[int, str]]]:
+def _read_material(path, what: str) -> str:
+    """資料の本文。資料が無ければ ValueError（文言の主語は what）。"""
     p = Path(path)
     if not p.is_file():
-        raise ValueError(f"承認資料 {p} が無い")
-    lines = p.read_text(encoding="utf-8").split("\n")
+        raise ValueError(f"{what} {p} が無い")
+    return p.read_text(encoding="utf-8")
+
+
+def _cells(path) -> tuple[list[str], dict[str, tuple[int, str]]]:
+    lines = _read_material(path, "承認資料").split("\n")
     rows = {}
     for i, line in enumerate(lines):
         m = re.match(r"^\| ([^|]+?) \| (.*?) \|$", line)
@@ -88,25 +93,36 @@ def _cells(path) -> tuple[list[str], dict[str, tuple[int, str]]]:
     return lines, rows
 
 
-def material_sha(path) -> str:
-    """承認資料の「承認したコミット」の欄の SHA。資料・欄が無い・形が違えば ValueError（承認の記録は見ない）。"""
-    _, rows = _cells(path)
+def _material_sha_of(rows, path) -> str:
+    """_cells の rows から「承認したコミット」の欄の SHA を取り出す。欄が無い・形が違えば ValueError。"""
     if ROW not in rows:
         raise ValueError(f"承認資料 {path} に「{ROW}」の欄が無い")
     return parse_sha(rows[ROW][1])
 
 
+def _recorded_sha_of(rows) -> str | None:
+    """_cells の rows から「承認の記録」の SHA を取り出す。無ければ None。"""
+    m = _RECORD_RE.match(rows.get(RECORD, (0, ""))[1])
+    return m.group(1) if m else None
+
+
+def material_sha(path) -> str:
+    """承認資料の「承認したコミット」の欄の SHA。資料・欄が無い・形が違えば ValueError（承認の記録は見ない）。"""
+    _, rows = _cells(path)
+    return _material_sha_of(rows, path)
+
+
 def recorded_sha(path) -> str | None:
     """承認資料の「承認の記録」の SHA。無ければ None。"""
     _, rows = _cells(path)
-    m = _RECORD_RE.match(rows.get(RECORD, (0, ""))[1])
-    return m.group(1) if m else None
+    return _recorded_sha_of(rows)
 
 
 def from_material(path) -> str:
     """承認資料から承認したコミットを読む。承認の記録が無いか SHA が違えば Unapproved（I10）。"""
-    sha = material_sha(path)
-    rec = recorded_sha(path)
+    _, rows = _cells(path)
+    sha = _material_sha_of(rows, path)
+    rec = _recorded_sha_of(rows)
     if rec != sha:
         raise Unapproved(sha, rec)
     return sha
@@ -116,10 +132,10 @@ def record_approval(path, sha: str, by: str, at: str) -> None:
     """承認資料の「承認したコミット」の行の直後へ承認の記録を書く（あれば置き換える）。
     sha が資料の承認したコミットと違えば書かずに Unapproved（提示の後に資料が書き直された）。"""
     sha = parse_sha(sha)
-    now = material_sha(path)
+    lines, rows = _cells(path)
+    now = _material_sha_of(rows, path)
     if now != sha:
         raise Unapproved(now, sha)
-    lines, rows = _cells(path)
     row = f"| {RECORD} | {sha} を {by} が {at} に承認 |"
     if RECORD in rows:
         lines[rows[RECORD][0]] = row
@@ -171,13 +187,12 @@ def verified_sha(path) -> str:
     """導入の確認の承認資料から確かめたコミットを読む（`merged-steps.py promote --expect-head-from`）。
     資料が無い・行が無い・行が 2 つ以上・40 桁の 16 進でなければ ValueError（照合を飛ばさない）。"""
     p = Path(path)
-    if not p.is_file():
-        raise ValueError(f"導入の確認の承認資料 {p} が無い")
-    found = [m.group(1) for m in (_VERIFIED_RE.match(line) for line in p.read_text(encoding="utf-8").split("\n")) if m]
+    text = _read_material(p, "導入の確認の承認資料")
+    found = [m.group(1) for m in (_VERIFIED_RE.match(line) for line in text.split("\n")) if m]
     if len(found) != 1:
         what = "無い" if not found else f"{len(found)} 行ある"
         raise ValueError(f"導入の確認の承認資料 {p} に確かめたコミットの行が{what}")
-    return parse_sha(found[0])
+    return parse_sha(found[0], f"導入の確認の承認資料 {p} の確かめたコミット")
 
 
 # --- 比較 ---------------------------------------------------------------------
diff --git a/plugins/ndf/scripts/merged-steps.py b/plugins/ndf/scripts/merged-steps.py
index 4ca87bdb6..6e8dea7d5 100755
--- a/plugins/ndf/scripts/merged-steps.py
+++ b/plugins/ndf/scripts/merged-steps.py
@@ -6,7 +6,7 @@
     python3 merged-steps.py merge-gate (--base <宛先> | --pr <PR番号>) [--pr <PR番号>] [--root <dir>]
     python3 merged-steps.py merge-when-green <PR番号> [--gate-approved user|mvv] [--method merge|squash|rebase]
                             [--interval 秒] [--timeout 秒] [--stale-after 秒] [--no-cleanup] [--expect-head <SHA>] [--root <dir>]
-    python3 merged-steps.py promote --head <ベースブランチ> --base <本番チャネル> [--prepare] [--gate-approved user|mvv] [--expect-head-from <資料>]
+    python3 merged-steps.py promote --head <ベースブランチ> --base <本番チャネル> [--prepare] [--out <資料>] [--gate-approved user|mvv] [--expect-head-from <資料> | --approved-from <資料>]
 
 cleanup: マージ済みの PR の作業ツリーとローカルブランチを外し、主ディレクトリを取り込む。
 `git worktree remove` が拒否した作業ツリーは、未追跡・無視されたファイルを退避してから外す。作り直せる生成物
@@ -20,7 +20,7 @@
 CI を待たずに承認ゲート 2 で止まる（status: gate・metrics.gate: production-merge。判定は lib/delivery.py。#1336）。
 merge-gate: 宛先の判定だけを行う（0 = 進めてよい / 10 = 承認ゲート 2）。
 promote: 昇格の Pull Request（ベースブランチ → 本番チャネル）を探すか作り、merge-when-green と同じ判定と待ちでマージする（後片付けはしない）。
---prepare は用意して承認資料を書くところで 0 で終える。--expect-head-from は導入の確認の承認資料の確かめたコミットを --expect-head と同じ照合に使う（違えば head_moved で 1、読めなければ 2。#1529）。
+--prepare は用意して承認資料を書くところで 0 で終える。--expect-head-from は導入の確認の承認資料の確かめたコミットを --expect-head と同じ照合に使う（違えば head_moved で 1、読めなければ 2。どちらもマージせず、プランの handoff が承認ゲート 2 の by: mvv の記録を外して 10 を返し、承認ゲート 2 へ戻す。流し直しは run <プラン> --from verify。#1529）。承認ゲート 2 で止まるときは先端を「承認したコミット」として承認資料（--out）と metrics.approved_sha に載せ、--approved-from はその資料の承認したコミットを同じ照合に使う（--gate-approved user に要る。#2104）。
 実行が終わったのにチェックが pending のまま --stale-after 秒続けば、そのジョブを 1 度だけ `gh run rerun --job` で再実行し、
 再実行でも取り残されれば止まる。実行が終わりジョブに結論があれば、チェックの表示が pending のままでも待たずにその結論で扱う。
 ジョブがランナーを待つ間は、待ち行列の件数を待ちの 1 周ごとに stderr へ 1 行出す。同じチェック（workflow の名前と名前の組）は最新の項目だけで数え、古い項目の失敗は items に result: superseded で残す。
@@ -73,6 +73,8 @@
 from merged_lib import base_sync, merge, trash  # noqa: E402
 from merged_lib.pull import blocking_local_changes, same_untracked  # noqa: E402,F401
 from merged_lib.checks import queued_run_count  # noqa: E402
+from merged_lib.pr_info import merged_pr_info  # noqa: E402
+from merged_lib.probe_table import PROBE_ACTIONS, PROBE_CLASSES, PROBE_REMEDIED_SUMMARY, PROBE_TABLE  # noqa: E402
 from merged_lib.reading import read_checks  # noqa: E402
 
 TOOL = "merged"
@@ -161,23 +163,8 @@ def _remove_pr_tmp_worktree(root, tmp_wt, n, add, merge_commit=None):
         add("worktree", w["path"], "removed" if ok else "kept", why)
 
 
-def _cleanup_pr(root, main_dir, slug, wt_base, n, add):
-    """PR 1 件分の作業ツリーとブランチを片付ける。"""
-    p = gh_parts.gh(["pr", "view", str(n), "--json", "headRefName,state,mergeCommit"], cwd=root)
-    if p.returncode != 0:
-        add("pr", f"#{n}", "kept", f"gh pr view が失敗: {p.stderr.strip()[:200]}")
-        return
-    try:
-        info = json.loads(p.stdout)
-    except ValueError:
-        add("pr", f"#{n}", "kept", "gh pr view の出力を読めない")
-        return
-    branch = info.get("headRefName")
-    if info.get("state") != "MERGED":
-        add("pr", branch or f"#{n}", "kept", f"#{n} が MERGED でない（{info.get('state')}）")
-        return
-
-    merge_commit = (info.get("mergeCommit") or {}).get("oid")
+def _remove_pr_worktrees(root, main_dir, branch, merge_commit, add):
+    """branch を checkout した作業ツリーを外す。ブランチを消してよい（使う作業ツリーが残らない）かを返す。"""
     branch_free = True
     for wt in list_worktrees(root):
         if wt["branch"] != branch:
@@ -189,8 +176,16 @@ def _cleanup_pr(root, main_dir, slug, wt_base, n, add):
         ok, why = remove_worktree(root, wt["path"], branch, merge_commit)
         add("worktree", wt["path"], "removed" if ok else "kept", why)
         branch_free = branch_free and ok
+    return branch_free
 
-    if branch_free:
+
+def _cleanup_pr(root, main_dir, slug, wt_base, n, add):
+    """PR 1 件分の作業ツリーとブランチを片付ける。"""
+    got = merged_pr_info(root, n, add)
+    if got is None:
+        return
+    branch, merge_commit = got
+    if _remove_pr_worktrees(root, main_dir, branch, merge_commit, add):
         _delete_branch(root, branch, add)
 
     if slug:
@@ -318,20 +313,6 @@ def cmd_promote(a):
 
 # --- probe --------------------------------------------------------------------
 
-# 分類は強い順。PR が 2 つ以上に当たれば上を採り、複数の PR は最も上の分類で全体を表す
-PROBE_CLASSES = ("failed", "stale", "stale_again", "infra", "settled", "queued", "running", "passed", "none")
-PROBE_ACTIONS = {
-    "failed": "fix",
-    "stale": "judge",
-    "stale_again": "judge",
-    "infra": "wait",  # Runner が付かずに取り消された（CI の基盤待ち）。再実行は merge-when-green が持つ
-    "settled": "wait",
-    "queued": "wait",
-    "running": "wait",
-    "passed": "judge",
-    "none": "judge",
-}
-
 
 def probe_prs(root, a):
     """調べる開いた PR の番号。--pr はそのまま、--head は開いた PR を探す。"""
@@ -427,17 +408,8 @@ def cmd_probe(a):
     queued_runs = (queued_run_count(root) or 0) if cls == "queued" else 0
     prs = [f[0] for f in found]
     names = ", ".join(i["name"] for i in items if i.get("kind") == "check" and i.get("result") != "superseded") or "無し"
-    summary = {
-        "failed": f"失敗したチェックがある: {names}",
-        "stale": ("取り残されたチェックを再実行した: " if action == "remedied" else "取り残されたチェックがある: ") + names,
-        "stale_again": f"再実行したチェックが再び取り残された: {names}",
-        "infra": f"Runner が付かずに取り消されたジョブがある（CI の基盤待ち）: {names}",
-        "settled": f"実行は終わりジョブに結論がある（表示だけが pending）: {names}",
-        "queued": f"ジョブがランナーを待っている（待ち行列 {queued_runs} 件）: {names}",
-        "running": f"実行中のチェックがある: {names}",
-        "passed": "すべてのチェックが通っている（待つ側が抜けていない）",
-        "none": "開いた PR が無い・読めない",
-    }[cls]
+    template = PROBE_REMEDIED_SUMMARY if cls == "stale" and action == "remedied" else PROBE_TABLE[cls][1]
+    summary = template.format(names=names, queued_runs=queued_runs)
     pr_text = " ".join(f"#{n}" for n in prs)
     emit(
         result(TOOL, "ok", f"{pr_text} {summary}".strip(), items, {"class": cls, "action": action, "prs": prs, "queued_runs": queued_runs}),
@@ -476,9 +448,7 @@ def build_parser():
     )
     pm.add_argument("--head", required=True, help="昇格させるブランチ（ベースブランチ）")
     pm.add_argument("--base", required=True, help="本番チャネル")
-    pm.add_argument("--prepare", action="store_true", help="Pull Request を用意して承認資料を書くところで終える（マージしない）")
-    pm.add_argument("--out", help="--prepare の承認資料の置き場（既定は提示物の置き場）")
-    pm.add_argument("--expect-head-from", metavar="資料", help="導入の確認の承認資料。確かめたコミットが PR の先端のときだけマージする")
+    merge.add_promote_args(pm)
     merge.add_wait_args(pm)
     pm.set_defaults(func=cmd_promote)
     pr = sub.add_parser(
diff --git a/plugins/ndf/scripts/merged_lib/checks.py b/plugins/ndf/scripts/merged_lib/checks.py
index 41d6ed82e..1499fda35 100644
--- a/plugins/ndf/scripts/merged_lib/checks.py
+++ b/plugins/ndf/scripts/merged_lib/checks.py
@@ -172,8 +172,9 @@ class GreenWatch:
     """merge-when-green の 1 回の読み直し（`poll`）と、その間の状態。待ちの間隔は lib/waits.py の `wait_until` が持ち、
     読んだ中身が変わらない間は伸ばす。pending を見ずに通ったときの確かめ直しだけは --recheck の間隔で眠る。"""
 
-    def __init__(self, root, a):
+    def __init__(self, root, a, moved_next=None):
         self.root, self.a, self.n = root, a, a.pr
+        self.moved_next = moved_next  # 先端が照合と違って止まるときの続け方（promote の --approved-from。#2104）
         self.deadline = time.monotonic() + a.timeout
         self.items, self.waits, self.queued_runs = [], 0, 0
         self.green_sha = None  # pending を見ずに通った状態を 1 度見た先頭のコミット。確かめ直して通れば確定とする
@@ -291,7 +292,7 @@ def _stop_infra(self, reading: CheckReading, why: str, detail: str = ""):
             EXIT_INFRA_WAIT,
         )
 
-    def _stop_conflict(self, why: str = "mergeStateStatus=DIRTY"):
+    def stop_conflict(self, why: str = "mergeStateStatus=DIRTY"):
         """PR がベースブランチと衝突している（終了コード 4。#1917）。プランの merge はベースブランチの取り込みへ戻る。"""
         n = self.n
         emit(
@@ -308,7 +309,8 @@ def _stop_conflict(self, why: str = "mergeStateStatus=DIRTY"):
 
     def _check_expected(self, sha, state):
         """--expect-head を渡したとき、読んだ先端がその SHA と違えば、待ち続けず・マージ済みでもそこで止める（#815 の I5）。
-        待つ間に別の先端でマージされた PR を成功として返さない（release が承認していないマージへタグを打たない）。"""
+        待つ間に別の先端でマージされた PR を成功として返さない（release が承認していないマージへタグを打たない）。
+        呼び手が続け方（moved_next。promote の --approved-from。#2104）を渡していれば next に載せる。"""
         expect = getattr(self.a, "expect_head", None)
         if not expect or sha == expect:
             return
@@ -320,19 +322,18 @@ def _check_expected(self, sha, state):
                 f"#{n} の先端が {expect[:8]} でない（今は {str(sha)[:8]}・{state}）。マージしない",
                 self.items + [{"kind": "pr", "name": f"#{n}", "result": "head_moved", "head": sha, "expected": expect}],
                 {"waits": self.waits},
+                next=self.moved_next,
             )
         )
 
-    def poll(self):
-        """1 回読む。終われば ("done", 理由)、待つなら ("wait", 読んだ中身)。止めるときは emit で抜ける。"""
-        root, a, n, items, waits = self.root, self.a, self.n, self.items, self.waits
-        info = pr_state(root, n)
+    def _inspect_pr(self, info) -> bool:
+        """PR の状態を検査する。マージ済みなら True。OPEN でない・衝突しているときは emit で抜ける。"""
+        n = self.n
         state, sha = info.get("state"), info.get("headRefOid")
-        self.recheck = False
         self._check_expected(sha, state)
         if state == "MERGED":
-            items.append({"kind": "pr", "name": f"#{n}", "result": "already_merged"})
-            return ("done", "merged")
+            self.items.append({"kind": "pr", "name": f"#{n}", "result": "already_merged"})
+            return True
         if state != "OPEN":
             emit(
                 result(
@@ -348,21 +349,23 @@ def poll(self):
         if info.get("isDraft"):
             self._ensure_ready()
         if info.get("mergeStateStatus") == "DIRTY":  # UNKNOWN（計算中）は衝突と読まずに待つ
-            self._stop_conflict()
-        self._reset_on_new_sha(sha)
-        self.last_sha = sha
-        reading = read_checks(root, info.get("statusCheckRollup"), self.seen_jobs)
-        self._note(reading)
+            self.stop_conflict()
+        return False
+
+    def _handle_failures(self, reading: CheckReading):
+        """中身の失敗なら止める。基盤待ちは再実行を進め、解けなければ止める。止めるときは emit で抜ける。"""
         if reading.failed:
             self._stop_failed(reading)
         if reading.infra:
-            why, detail = self.infra.step(root, reading, time.monotonic())
-            items += self.infra.log
+            why, detail = self.infra.step(self.root, reading, time.monotonic())
+            self.items += self.infra.log
             self.infra.log.clear()
             if why != "wait":
                 self._stop_infra(reading, why, detail)
-        pending = [i.label for i in reading.pending]
-        passed = [i.label for i in reading.passed]
+
+    def _classify_progress(self, sha, reading: CheckReading, pending, passed):
+        """チェックの進み具合を分ける。終われば ("done", 理由)、待つなら ("wait", None)。"""
+        a, items = self.a, self.items
         if not pending and not passed and not reading.infra:
             # チェックがまだ載っていない。--no-checks-after 秒を過ぎても空なら CI の無いリポジトリとみなす
             self.empty_since = self.empty_since if self.empty_since is not None else time.monotonic()
@@ -379,21 +382,47 @@ def poll(self):
             self.green_sha, self.pending_sha, self.empty_since = None, sha, None
             if pending:
                 probed = (reading.stale, reading.queued)
-                count = watch_stuck_checks(root, probed, a, StuckWatch(n, items, waits, self.stale_since, self.rerun_done))
+                stuck = StuckWatch(self.n, items, self.waits, self.stale_since, self.rerun_done)
+                count = watch_stuck_checks(self.root, probed, a, stuck)
                 if count is not None:
                     self.queued_runs = count  # 最後に見た待ち行列の件数
-        if time.monotonic() >= self.deadline:
-            if reading.infra or self.infra.pending_reruns(reading):
-                self._stop_infra(reading, "timeout")
-            emit(
-                result(
-                    TOOL,
-                    "stopped",
-                    f"#{n} の CI が {a.timeout} 秒で終わらない（待ち: {', '.join(pending)}）",
-                    items + [{"kind": "check", "name": c, "result": "pending"} for c in pending],
-                    {"failed": 0, "pending": len(pending), "passed": len(passed), "waits": waits, "queued_runs": self.queued_runs},
-                    next=f"打ち直す: merged-steps.py merge-when-green {n}",
-                )
+        return ("wait", None)
+
+    def _check_deadline(self, reading: CheckReading, pending, passed):
+        """締め切りを過ぎていれば止める（基盤待ちが残れば基盤待ちとして）。止めるときは emit で抜ける。"""
+        if time.monotonic() < self.deadline:
+            return
+        n, a = self.n, self.a
+        if reading.infra or self.infra.pending_reruns(reading):
+            self._stop_infra(reading, "timeout")
+        emit(
+            result(
+                TOOL,
+                "stopped",
+                f"#{n} の CI が {a.timeout} 秒で終わらない（待ち: {', '.join(pending)}）",
+                self.items + [{"kind": "check", "name": c, "result": "pending"} for c in pending],
+                {"failed": 0, "pending": len(pending), "passed": len(passed), "waits": self.waits, "queued_runs": self.queued_runs},
+                next=f"打ち直す: merged-steps.py merge-when-green {n}",
             )
+        )
+
+    def poll(self):
+        """1 回読む。終われば ("done", 理由)、待つなら ("wait", 読んだ中身)。止めるときは emit で抜ける。"""
+        info = pr_state(self.root, self.n)
+        sha = info.get("headRefOid")
+        self.recheck = False
+        if self._inspect_pr(info):
+            return ("done", "merged")
+        self._reset_on_new_sha(sha)
+        self.last_sha = sha
+        reading = read_checks(self.root, info.get("statusCheckRollup"), self.seen_jobs)
+        self._note(reading)
+        self._handle_failures(reading)
+        pending = [i.label for i in reading.pending]
+        passed = [i.label for i in reading.passed]
+        verdict = self._classify_progress(sha, reading, pending, passed)
+        if verdict[0] == "done":
+            return verdict
+        self._check_deadline(reading, pending, passed)
         infra = tuple(sorted(i.label for i in reading.infra))
         return ("wait", (sha, tuple(sorted(pending)), tuple(sorted(passed)), infra, self.recheck))
diff --git a/plugins/ndf/scripts/merged_lib/merge.py b/plugins/ndf/scripts/merged_lib/merge.py
index a5d9538fd..6313dd6bb 100644
--- a/plugins/ndf/scripts/merged_lib/merge.py
+++ b/plugins/ndf/scripts/merged_lib/merge.py
@@ -52,6 +52,27 @@ def add_wait_args(m):
     )
 
 
+def add_promote_args(pm):
+    """promote だけが受ける、用意と照合の引数（#1529・#2104）。"""
+    pm.add_argument("--prepare", action="store_true", help="Pull Request を用意して承認資料を書くところで終える（マージしない）")
+    pm.add_argument("--out", help="--prepare と承認ゲート 2 の停止で書く昇格の承認資料の置き場（既定は提示物の置き場）")
+    pin = pm.add_mutually_exclusive_group()
+    pin.add_argument(
+        "--expect-head-from",
+        metavar="資料",
+        help=(
+            "導入の確認の承認資料。確かめたコミットが PR の先端のときだけマージする（照合）。"
+            "食い違えば head_moved で 1、資料から読めなければ 2 で止まり、プランの handoff が承認ゲート 2 へ戻す"
+            "（run <プラン> --from verify から流し直す）"
+        ),
+    )
+    pin.add_argument(
+        "--approved-from",
+        metavar="資料",
+        help="昇格の承認資料。承認したコミットが PR の先端のときだけマージする（--gate-approved user に要る）",
+    )
+
+
 # --- 承認ゲート 2（自動反映の本番チャネルへのマージ。#1336） ------------------------
 
 GATE = "production-merge"
@@ -71,8 +92,11 @@ def _judge_rows(verdict):
     return [("判定", verdict.value), ("理由", verdict.reason), *[(i["name"], i["result"]) for i in verdict.items]]
 
 
-def gate_stop(n, verdict, info=None, next_cmd=None, plan_step="merge-approved"):
-    """承認の無い本番系へのマージを止める結果（status: gate・終了コード 10）を出して終える。承認資料を書く。"""
+def gate_stop(n, verdict, info=None, next_cmd=None, plan_step="merge-approved", approved_sha=None, out=None):
+    """承認の無い本番系へのマージを止める結果（status: gate・終了コード 10）を出して終える。承認資料を書く。
+    approved_sha（昇格の Pull Request の先端。#2104）があれば、判断の表の先頭へ「承認したコミット」の行を置き、
+    metrics.approved_sha と gate の items[].head にも載せる。out は承認資料の置き場（無ければ既定の置き場）。
+    next_cmd は文字列か、書いた承認資料のパスを受けて打ち方を返す関数。"""
     info = info or {}
     target = verdict.target or "（不明）"
     what = f"#{n}" if n else f"宛先 {target} へのマージ"
@@ -93,19 +117,26 @@ def gate_stop(n, verdict, info=None, next_cmd=None, plan_step="merge-approved"):
         title=f"{what} のマージ（本番系への反映。承認ゲート 2）",
         targets=[target_row],
         change=change,
-        judge=[*_judge_rows(verdict), ("宛先", target)],
+        judge=[*([approved_commit.material_row(approved_sha)] if approved_sha else []), *_judge_rows(verdict), ("宛先", target)],
         consent=[f"{what} を {target} へマージし、本番系へ反映する"],
         rollback=GATE_ROLLBACK,
+        path=out,
     )
+    if callable(next_cmd):
+        next_cmd = next_cmd(path)
     cmd = next_cmd or (f"merge-when-green {n} --gate-approved user" if n else "merge-when-green <PR番号> --gate-approved user")
-    items = verdict.items + [{"kind": "pr", "name": what, "result": "gate", "base": target}]
+    item = {"kind": "pr", "name": what, "result": "gate", "base": target}
+    metrics = {"gate": GATE, "verdict": verdict.value, "target": target}
+    if approved_sha:
+        item["head"] = metrics["approved_sha"] = approved_sha
+    items = verdict.items + [item]
     emit(
         result(
             TOOL,
             "gate",
             f"{lead}。承認ゲート 2 の承認が要る",
             items,
-            {"gate": GATE, "verdict": verdict.value, "target": target},
+            metrics,
             path,
             f"承認を得たら {cmd}（プランなら run <プラン> --from {plan_step}）",
         )
@@ -190,7 +221,7 @@ def _merge_pr(root, a, n, watch, items, waits):
     p = gh_parts.gh(["pr", "merge", str(n), "--admin", f"--{a.method}", *pin], cwd=root)
     if p.returncode != 0:
         if _conflicted(root, n, p.stderr or ""):
-            watch._stop_conflict("gh pr merge がマージのコミットを作れずに拒んだ")
+            watch.stop_conflict("gh pr merge がマージのコミットを作れずに拒んだ")
         emit(
             result(
                 TOOL,
@@ -207,11 +238,21 @@ def _merge_pr(root, a, n, watch, items, waits):
     items.append(merged)
 
 
-def merge_when_green(a, cleanup, next_cmd=None, plan_step="merge-approved"):
+def _gate_head(info):
+    """承認ゲート 2 で止まる判定に使った読みの先端（承認資料へ載せる承認したコミット）。読めなければ止まる（#2104 の I1）。"""
+    try:
+        return approved_commit.parse_sha(info.get("headRefOid"))
+    except ValueError as e:
+        raise StepError(f"昇格の Pull Request の先端を読めないため承認資料を書かない: {e}", EXIT_UNREADABLE) from e
+
+
+def merge_when_green(a, cleanup, next_cmd=None, plan_step="merge-approved", gate_head=False, moved_next=None):
+    """gate_head なら、承認ゲート 2 で止まるときに最初の読みの先端を承認資料へ載せる（promote。#2104）。
+    moved_next は、先端が --expect-head と違って止まるときに next へ載せる続け方。"""
     root = git_root(a.root)
     n = a.pr
     decl = delivery.load_delivery(root)  # 判定は保存しない。呼ぶたびに宣言から作り直す
-    watch = GreenWatch(root, a)
+    watch = GreenWatch(root, a, moved_next=moved_next)
     judged = {}
 
     def gate(info):
@@ -219,7 +260,8 @@ def gate(info):
         verdict = delivery.judge_target(decl, info.get("baseRefName") or "")
         judged["verdict"] = verdict
         if verdict.stops and not a.gate_approved:
-            gate_stop(n, verdict, info, next_cmd, plan_step)
+            sha = _gate_head(info) if gate_head else None
+            gate_stop(n, verdict, info, next_cmd, plan_step, sha, getattr(a, "out", None) if gate_head else None)
 
     watch.on_open = gate
     watch.wait()
@@ -286,7 +328,7 @@ def _prepare_promote(root, a, n, item):
         title=f"#{n} の昇格（{a.head} → {a.base}。承認ゲート 2）",
         targets=[{"url": info.get("url") or f"#{n}", "title": info.get("title"), "base_head": f"{a.base} ← {a.head}"}],
         change=_change_text(info),
-        judge=_judge_rows(verdict),
+        judge=[approved_commit.material_row(_gate_head(info)), *_judge_rows(verdict)],
         consent=[f"#{n} を {a.base} へマージし、本番系へ反映する"],
         rollback=GATE_ROLLBACK,
         path=a.out,
@@ -303,21 +345,57 @@ def _prepare_promote(root, a, n, item):
     )
 
 
+def _pin_expect_head(a, reader, path, what):
+    """資料から SHA を読み、照合に使う a.expect_head へ入れる。読めなければ gh を呼ばずに EXIT_UNREADABLE で止まる。"""
+    try:
+        a.expect_head = reader(path)
+    except ValueError as e:
+        raise StepError(f"{what}を読めないため昇格しない: {e}", EXIT_UNREADABLE) from e
+
+
 def promote(a, cleanup):
     """ベースブランチ（--head）から本番チャネル（--base）への昇格の Pull Request を作り（あれば使い）、承認ゲート 2 の後にマージする。
     head はベースブランチなので、マージの後に後片付けをしない（#1336 の I7）。
     --expect-head-from があれば、最初に導入の確認の承認資料から確かめたコミットを読み、merge-when-green の
-    --expect-head と同じ照合に使う。読めなければ gh を呼ばずに EXIT_UNREADABLE で止まる（照合を飛ばさない。#1529）。"""
+    --expect-head と同じ照合に使う。読めなければ gh を呼ばずに EXIT_UNREADABLE で止まる（照合を飛ばさない。#1529）。
+    --approved-from があれば、昇格の承認資料の承認したコミットを同じ照合に使い、先端が違えば承認ゲート 2 から
+    やり直す打ち方を next に載せる。--gate-approved user は --approved-from 無しでは受けない（#2104 の I3〜I5）。"""
     src = getattr(a, "expect_head_from", None)
     if src:
-        try:
-            a.expect_head = approved_commit.verified_sha(src)
-        except ValueError as e:
-            raise StepError(f"確かめたコミットを読めないため昇格しない: {e}", EXIT_UNREADABLE) from e
+        _pin_expect_head(a, approved_commit.verified_sha, src, "確かめたコミット")
+    approved_from = getattr(a, "approved_from", None)
+    moved_next = None
+    if a.gate_approved == "user" and not approved_from:
+        emit(
+            result(
+                TOOL,
+                "stopped",
+                "--gate-approved user に照合の材料（--approved-from の昇格の承認資料）が無いため昇格しない",
+                next=(
+                    f"promote --head {a.head} --base {a.base} --gate-approved user --approved-from <承認資料> で打つ"
+                    "（プランなら run <プラン> --from promote から流し直し、承認ゲート 2 を取り直す）"
+                ),
+            ),
+            EXIT_UNREADABLE,
+        )
+    if approved_from:
+        _pin_expect_head(a, approved_commit.material_sha, approved_from, "承認したコミット")
+        moved_next = (
+            "承認ゲート 2 からやり直す: プランなら run <プラン> --from promote（fast / auto は --from verify）。"
+            "承認資料を新しい先端で作り直してから承認を求める"
+        )
     root = git_root(a.root)
     n, created = _find_or_create_promote_pr(root, a.head, a.base)
     item = {"kind": "pr", "name": f"#{n}", "result": "created" if created else "found", "base": a.base, "head_branch": a.head}
     if a.prepare:
         _prepare_promote(root, a, n, item)
     a.pr, a.no_cleanup = n, True
-    merge_when_green(a, cleanup, next_cmd=f"promote --head {a.head} --base {a.base} --gate-approved user", plan_step="promote-approved")
+    approve = f"promote --head {a.head} --base {a.base} --gate-approved user --approved-from "
+    merge_when_green(
+        a,
+        cleanup,
+        next_cmd=lambda path: approve + str(path),
+        plan_step="promote-approved",
+        gate_head=True,
+        moved_next=moved_next,
+    )
diff --git a/plugins/ndf/scripts/merged_lib/pr_info.py b/plugins/ndf/scripts/merged_lib/pr_info.py
new file mode 100644
index 000000000..cd115c407
--- /dev/null
+++ b/plugins/ndf/scripts/merged_lib/pr_info.py
@@ -0,0 +1,25 @@
+"""マージ済みの PR の情報の読み取り（`merged-steps.py` の cleanup から分けた）。"""
+
+from __future__ import annotations
+
+import json
+
+import gh_parts
+
+
+def merged_pr_info(root, n, add):
+    """PR n の (ブランチ, マージコミット) を返す。読めない・MERGED でないときは記録して None。"""
+    p = gh_parts.gh(["pr", "view", str(n), "--json", "headRefName,state,mergeCommit"], cwd=root)
+    if p.returncode != 0:
+        add("pr", f"#{n}", "kept", f"gh pr view が失敗: {p.stderr.strip()[:200]}")
+        return None
+    try:
+        info = json.loads(p.stdout)
+    except ValueError:
+        add("pr", f"#{n}", "kept", "gh pr view の出力を読めない")
+        return None
+    branch = info.get("headRefName")
+    if info.get("state") != "MERGED":
+        add("pr", branch or f"#{n}", "kept", f"#{n} が MERGED でない（{info.get('state')}）")
+        return None
+    return branch, (info.get("mergeCommit") or {}).get("oid")
diff --git a/plugins/ndf/scripts/merged_lib/probe_table.py b/plugins/ndf/scripts/merged_lib/probe_table.py
new file mode 100644
index 000000000..728635932
--- /dev/null
+++ b/plugins/ndf/scripts/merged_lib/probe_table.py
@@ -0,0 +1,19 @@
+"""probe の分類の対応表（`merged-steps.py` の cmd_probe から分けた）。"""
+
+# 分類ごとの (手, 要約)。並びは強い順で、PR が 2 つ以上に当たれば上を採り、複数の PR は最も上の分類で全体を表す。
+# 要約の {names} は根拠のチェック名、{queued_runs} は待ち行列の件数
+PROBE_TABLE = {
+    "failed": ("fix", "失敗したチェックがある: {names}"),
+    "stale": ("judge", "取り残されたチェックがある: {names}"),
+    "stale_again": ("judge", "再実行したチェックが再び取り残された: {names}"),
+    # Runner が付かずに取り消された（CI の基盤待ち）。再実行は merge-when-green が持つ
+    "infra": ("wait", "Runner が付かずに取り消されたジョブがある（CI の基盤待ち）: {names}"),
+    "settled": ("wait", "実行は終わりジョブに結論がある（表示だけが pending）: {names}"),
+    "queued": ("wait", "ジョブがランナーを待っている（待ち行列 {queued_runs} 件）: {names}"),
+    "running": ("wait", "実行中のチェックがある: {names}"),
+    "passed": ("judge", "すべてのチェックが通っている（待つ側が抜けていない）"),
+    "none": ("judge", "開いた PR が無い・読めない"),
+}
+PROBE_REMEDIED_SUMMARY = "取り残されたチェックを再実行した: {names}"  # stale を --act で直したとき
+PROBE_CLASSES = tuple(PROBE_TABLE)
+PROBE_ACTIONS = {cls: action for cls, (action, _) in PROBE_TABLE.items()}
diff --git a/plugins/ndf/scripts/supervise_lib/delivery_templates.py b/plugins/ndf/scripts/supervise_lib/delivery_templates.py
index 4ee4eb5f9..726b7d8de 100644
--- a/plugins/ndf/scripts/supervise_lib/delivery_templates.py
+++ b/plugins/ndf/scripts/supervise_lib/delivery_templates.py
@@ -6,6 +6,7 @@
 from __future__ import annotations
 
 import shlex
+from dataclasses import dataclass
 from pathlib import Path
 
 from supervise_lib.decl import WORKTREE_DECL, DeclError, with_decls
@@ -16,6 +17,8 @@
 
 
 VERIFY_MATERIAL = "{state_dir}/work/approval-verify.md"  # verify-facts が書く承認資料（#1457）
+# 昇格の承認資料。normal は promote の承認ゲート 2 の停止が、fast / auto は prepare が書き、promote-approved が照合に読む（#2104）
+PROMOTE_MATERIAL = "{state_dir}/work/approval-promote.md"
 
 
 def facts_step(repo: str, cmd: str, next_id: str, step_id: str = "facts") -> dict:
@@ -52,26 +55,29 @@ def plan_verify(a, repo: str, verify: str, condition: dict | None = None) -> dic
     )
 
 
-def plan_promote(
-    a,
-    repo: str,
-    ci_wait: int,
-    mvv: str | None = None,
-    condition: dict | None = None,
-    production: str | None = None,
-    verify: str | None = None,
-) -> dict:
+@dataclass(frozen=True)
+class PromoteParams:
+    """昇格のプランに固有の入力。mvv はスプリントの状態（fast / auto）、production は本番チャネル、verify は導入の確認のコマンド。"""
+
+    mvv: str | None = None
+    production: str | None = None
+    verify: str | None = None
+
+
+def plan_promote(a, repo: str, ci_wait: int, params: PromoteParams = PromoteParams(), condition: dict | None = None) -> dict:
     """昇格のプラン（#1336 の F5）: ベースブランチ（a.base）から本番チャネル（a.production_branch）への Pull Request を
     `merged-steps.py promote` が作り（あれば使い）、承認ゲート 2 の後にマージする。後片付けはしない（head はベースブランチ）。
     マージの後に record（`release-steps.py record --promote`）が昇格の PR へリリース記録を書き、その PR を計画の
     Pull Request にする（まとめの close が `{queue_pr:promote}` で読む。#837）。record が落ちたら judge-record へ進む。
 
-    - normal（`mvv` 無し）: promote（承認の引数無し。承認ゲート 2 で終える）→ promote-approved（`--from` でだけ入る）
+    - normal（`mvv` 無し）: promote（承認の引数無し。昇格の承認資料 PROMOTE_MATERIAL へ先端を載せて承認ゲート 2 で終える）→
+      promote-approved（`--from` でだけ入る。PROMOTE_MATERIAL の承認したコミットのときだけマージする。#2104）
     - fast / auto（`mvv` にスプリントの状態）: verify（導入の確認。落ちたら止まる。#1457）→ prepare（PR と承認資料）→ mvv（承認ゲート 2 の MVV 判定）→ note（判定のコメント）→
       promote（`--gate-approved mvv`）。promote は mvv と同じ導入の確認の承認資料（VERIFY_MATERIAL）を `--expect-head-from` に受け、
       確かめたコミットのときだけマージする（#1529）。note か promote が落ちたら handoff が承認ゲートへ落とす
     """
-    head, base = a.base, production or a.production_branch
+    mvv, verify = params.mvv, params.verify
+    head, base = a.base, params.production or a.production_branch
     if not base:
         raise DeclError(f"昇格に要る本番チャネルが無い（--production-branch か .ndf/{WORKTREE_DECL} の production_branch）")
     promote = f"{MERGED_PY} promote --head {shlex.quote(head)} --base {shlex.quote(base)}"
@@ -82,7 +88,7 @@ def plan_promote(
         "type": "run",
         "stage": "配布",
         "timeout": timeout,
-        "cmd": promote + wait + " --gate-approved user",
+        "cmd": promote + wait + f" --approved-from {PROMOTE_MATERIAL} --gate-approved user",
         "next": "record",
     }
     record = [
@@ -100,58 +106,69 @@ def plan_promote(
         judge_record_step(),
     ]
     if not mvv:
-        steps = [
-            {
-                "id": "promote",
-                "type": "run",
-                "stage": "配布",
-                "timeout": timeout,
-                "cmd": promote + wait,
-                "gate_next": "end",
-                "next": "record",
-            },
-            approved,
-            *record,
-        ]
+        steps = _promote_steps_normal(promote, wait, timeout, approved, record)
     else:
-        if not verify:
-            raise DeclError("fast / auto の昇格のプランに導入の確認のコマンド（<節>.verify）が無い")
-        state = str(Path(mvv).resolve())
-        material = "{state_dir}/work/approval-promote.md"
-        pr_of = f'$(gh pr list --head {shlex.quote(head)} --base {shlex.quote(base)} --state open --json number --jq ".[0].number")'
-        steps = [
-            facts_step(repo, verify_facts_cmd(a, repo, verify), "prepare", "verify"),
-            {
-                "id": "prepare",
-                "type": "run",
-                "stage": "配布",
-                "timeout": 300,
-                "cmd": f"{promote} --prepare --out {material}",
-                "next": "mvv",
-            },
-            *mvv_gate_steps(
-                f"sh -c '{MVV_PY} check --sprint {shlex.quote(state)} --gate release --material {material} {VERIFY_MATERIAL} --pr {pr_of} "
-                f"--mode {a.mode} --root {shlex.quote(repo)} --note {MVV_NOTE}'",
-                f"sh -c 'gh pr comment {pr_of} --body-file {MVV_NOTE}'",
-                "promote",
-            ),
-            {
-                "id": "promote",
-                "type": "run",
-                "stage": "配布",
-                "timeout": timeout,
-                "cmd": promote + wait + f" --expect-head-from {VERIFY_MATERIAL} --gate-approved mvv",
-                "on_fail": "handoff",
-                "gate_next": "end",
-                "next": "record",
-            },
-            approved,
-            *record,
-            handoff_step(state, "関門 2", "昇格のマージ"),
-        ]
+        steps = _promote_steps_mvv(a, repo, head, base, promote, wait, timeout, verify, mvv, approved, record)
     return release_plan(a, repo, "配布（昇格）", RULE_PROMOTE, steps, condition)
 
 
+def _promote_steps_normal(promote: str, wait: str, timeout: int, approved: dict, record: list) -> list:
+    """normal の昇格の steps: promote（承認ゲート 2 で終える）→ promote-approved → record。"""
+    return [
+        {
+            "id": "promote",
+            "type": "run",
+            "stage": "配布",
+            "timeout": timeout,
+            "cmd": promote + wait + f" --out {PROMOTE_MATERIAL}",
+            "gate_next": "end",
+            "next": "record",
+        },
+        approved,
+        *record,
+    ]
+
+
+def _promote_steps_mvv(
+    a, repo: str, head: str, base: str, promote: str, wait: str, timeout: int, verify: str | None, mvv: str, approved: dict, record: list
+) -> list:
+    """fast / auto の昇格の steps: verify → prepare → mvv → note → promote（`--gate-approved mvv`）→ record。"""
+    if not verify:
+        raise DeclError("fast / auto の昇格のプランに導入の確認のコマンド（<節>.verify）が無い")
+    state = str(Path(mvv).resolve())
+    pr_of = f'$(gh pr list --head {shlex.quote(head)} --base {shlex.quote(base)} --state open --json number --jq ".[0].number")'
+    return [
+        facts_step(repo, verify_facts_cmd(a, repo, verify), "prepare", "verify"),
+        {
+            "id": "prepare",
+            "type": "run",
+            "stage": "配布",
+            "timeout": 300,
+            "cmd": f"{promote} --prepare --out {PROMOTE_MATERIAL}",
+            "next": "mvv",
+        },
+        *mvv_gate_steps(
+            f"sh -c '{MVV_PY} check --sprint {shlex.quote(state)} --gate release --material {PROMOTE_MATERIAL} {VERIFY_MATERIAL} --pr {pr_of} "
+            f"--mode {a.mode} --root {shlex.quote(repo)} --note {MVV_NOTE}'",
+            f"sh -c 'gh pr comment {pr_of} --body-file {MVV_NOTE}'",
+            "promote",
+        ),
+        {
+            "id": "promote",
+            "type": "run",
+            "stage": "配布",
+            "timeout": timeout,
+            "cmd": promote + wait + f" --expect-head-from {VERIFY_MATERIAL} --gate-approved mvv",
+            "on_fail": "handoff",
+            "gate_next": "end",
+            "next": "record",
+        },
+        approved,
+        *record,
+        handoff_step(state, "関門 2", "昇格のマージ"),
+    ]
+
+
 GATE_2_MATERIAL = "{state_dir}/work/approval-deploy.md"  # deploy-facts が書く承認資料
 
 
diff --git a/plugins/ndf/scripts/supervise_lib/sprint_routes.py b/plugins/ndf/scripts/supervise_lib/sprint_routes.py
index a66d60660..52f42827a 100644
--- a/plugins/ndf/scripts/supervise_lib/sprint_routes.py
+++ b/plugins/ndf/scripts/supervise_lib/sprint_routes.py
@@ -10,7 +10,7 @@
 from supervise_lib.decl import DeclError, decl_roots, delivery_decl, require_versions
 from supervise_lib.paths import HERE
 from supervise_lib.plan import QUEUE_PRS, sprint_state_path
-from supervise_lib.delivery_templates import GATE_2_MATERIAL, plan_gate_2, plan_promote, plan_verify
+from supervise_lib.delivery_templates import GATE_2_MATERIAL, PromoteParams, plan_gate_2, plan_promote, plan_verify
 from supervise_lib.release_templates import RELEASE_FORMS, material_path
 from supervise_lib.verify_steps import plan_limits
 
@@ -114,7 +114,7 @@ def route_waves(a, repo: str, then_of: str, mvv: str | None = None, condition: d
     verify = pace_verify(a) if mvv and (promote or merge) else None
     if promote:
         ci_wait = int(plan_limits(a)["ci_wait_timeout"])
-        plan = plan_promote(a, repo, ci_wait, mvv, condition, production=promote.branch, verify=verify)
+        plan = plan_promote(a, repo, ci_wait, PromoteParams(mvv=mvv, production=promote.branch, verify=verify), condition)
         wave = {"name": "本番", "plans": {"promote": plan}, "then_of": then_of}
         if note:
             wave["note"] = note
diff --git a/plugins/ndf/scripts/tests/pace_state.py b/plugins/ndf/scripts/tests/pace_state.py
new file mode 100644
index 000000000..1c2c8f733
--- /dev/null
+++ b/plugins/ndf/scripts/tests/pace_state.py
@@ -0,0 +1,27 @@
+"""supervise.py の pace（fast・auto）のテストに共通するスプリントの状態の土台。
+
+MVV の素材を置いて sprint-state.py init で状態を作り、approve なら MVV の承認を記録する。
+"""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+
+SPRINT_STATE = Path(__file__).resolve().parents[1] / "sprint-state.py"
+PY = sys.executable
+
+
+def sprint_state(tmp_path: Path, pace: str, approve: bool = True) -> Path:
+    mvv = tmp_path / "mvv-src.md"
+    mvv.write_text("## Mission\n速く\n## Vision\n回る\n## Value\n実測\n")
+    state = tmp_path / "state" / "sprint-state.json"
+    subprocess.run(
+        [PY, str(SPRINT_STATE), "init", str(state), "--name", "m", "--pace", pace, "--mvv", str(mvv), "--root", str(tmp_path)],
+        check=True,
+        capture_output=True,
+    )
+    if approve:
+        subprocess.run([PY, str(SPRINT_STATE), "gate", str(state), "MVV", "--what", "MVV を承認"], check=True, capture_output=True)
+    return state
diff --git a/plugins/ndf/scripts/tests/test_approved_commit.py b/plugins/ndf/scripts/tests/test_approved_commit.py
index 22c68d148..9b2b5e534 100644
--- a/plugins/ndf/scripts/tests/test_approved_commit.py
+++ b/plugins/ndf/scripts/tests/test_approved_commit.py
@@ -218,3 +218,13 @@ def test_verified_sha_rejects_an_unreadable_material(tmp_path: Path, text):
         p.write_text(text.format(l=ac.verified_line("trunk", "a" * 40), short=ac.verified_line("trunk", "a" * 39)))
     with pytest.raises(ValueError):
         ac.verified_sha(p)
+
+
+def test_verified_sha_names_the_verify_material_when_the_sha_is_malformed(tmp_path: Path):
+    """#2142: 40 桁でない確かめたコミットの文言は導入の確認の資料を指し、承認したコミットの文言は変わらない。"""
+    p = tmp_path / "approval-verify.md"
+    p.write_text(ac.verified_line("trunk", "a" * 39) + "\n")
+    with pytest.raises(ValueError, match="導入の確認の承認資料 .* の確かめたコミットが 40 桁"):
+        ac.verified_sha(p)
+    with pytest.raises(ValueError, match="^承認したコミットが 40 桁"):
+        ac.parse_sha("a" * 39)
diff --git a/plugins/ndf/scripts/tests/test_sprint_close_merge_green.py b/plugins/ndf/scripts/tests/test_sprint_close_merge_green.py
index 5c8db5b4e..d4962af72 100644
--- a/plugins/ndf/scripts/tests/test_sprint_close_merge_green.py
+++ b/plugins/ndf/scripts/tests/test_sprint_close_merge_green.py
@@ -19,6 +19,7 @@
 
 SCRIPTS = Path(__file__).resolve().parents[1]
 sys.path.insert(0, str(SCRIPTS / "lib"))
+import approved_commit  # noqa: E402
 from step_result import validate_result  # noqa: E402
 
 PY = sys.executable
@@ -887,10 +888,10 @@ def test_merge_gate_judges_without_gh(repo, gh):
 def test_promote_creates_pr_and_merges_after_approval_without_cleanup(repo, gh):
     """I7: 昇格の Pull Request を作り、承認が無ければ止め、承認があればマージして後片付けをしない。"""
     declare(repo, *TRYGROUP)
-    gh.set(create_number=9, pr_seq={"9": [dict(to("main"), headRefName="develop")]})
+    gh.set(create_number=9, pr_seq={"9": [dict(to("main", X), headRefName="develop")]})
     code, out, _ = call("merged-steps.py", ["promote", "--head", "develop", "--base", "main", "--interval", "0"], gh.env, repo)
     assert code == 10 and "promote-approved" in out["next"] and merges(gh) == []
-    gh.set(open_prs=[{"number": 9}], pr_seq={"9": [dict(to("main"), headRefName="develop")] * 3})
+    gh.set(open_prs=[{"number": 9}], pr_seq={"9": [dict(to("main", X), headRefName="develop")] * 3})
     code, out, err = call(
         "merged-steps.py",
         ["promote", "--head", "develop", "--base", "main", "--interval", "0", "--recheck", "0", "--gate-approved", "mvv"],
@@ -906,10 +907,11 @@ def test_promote_creates_pr_and_merges_after_approval_without_cleanup(repo, gh):
 
 def test_promote_prepare_writes_material_and_stops_short(repo, gh):
     declare(repo, *TRYGROUP)
-    gh.set(create_number=9, pr_seq={"9": [dict(to("main"), headRefName="develop")]})
+    gh.set(create_number=9, pr_seq={"9": [dict(to("main", X), headRefName="develop")]})
     code, out, _ = call("merged-steps.py", ["promote", "--head", "develop", "--base", "main", "--prepare"], gh.env, repo)
     assert code == 0 and out["metrics"]["pr"] == 9 and Path(out["presentation_path"]).is_file()
     assert merges(gh) == []
+    assert approved_commit.material_sha(out["presentation_path"]) == X  # #2104 の AC6・I2
 
 
 # --- #1485: 手動確認（マージ前）の行が未確認なら merge-gate が止まる ---------------------------------
@@ -1004,6 +1006,94 @@ def test_promote_does_not_merge_without_a_readable_verified_commit(repo, gh, tmp
 
 
 def test_promote_help_shows_the_verified_commit_argument(gh, repo):
-    """AC9: promote の --help に照合の引数が出る。"""
+    """AC9・#2142: promote の --help に照合の引数と、食い違えば承認ゲート 2 へ戻ることが出る。"""
     p = subprocess.run([PY, str(SCRIPTS / "merged-steps.py"), "promote", "--help"], capture_output=True, text=True, env=gh.env)
-    assert p.returncode == 0 and "--expect-head-from" in p.stdout
+    text = "".join(p.stdout.split())  # argparse の折り返しを外す
+    assert p.returncode == 0 and "--expect-head-from" in text
+    assert "承認ゲート2へ戻す" in text and "--fromverify" in text
+
+
+# --- #2104: 昇格の承認の後のマージは、承認ゲート 2 の承認資料の承認したコミットのときだけ行う ----------------------
+
+
+def promote_args(*extra):
+    return ["promote", "--head", "develop", "--base", "main", "--interval", "0", "--recheck", "0", *extra]
+
+
+def promote_material(tmp_path, sha=X, row="承認したコミット"):
+    """昇格の承認資料（gate_stop が書く形の判断の表の行）。sha が None なら資料を作らない。"""
+    p = tmp_path / "approval-promote.md"
+    if sha is not None:
+        p.write_text(f"## 2. 承認の判断に使うもの\n\n| 項目 | 内容 |\n| --- | --- |\n| {row} | {sha} |\n", encoding="utf-8")
+    return p
+
+
+def test_promote_gate_writes_the_head_into_the_material(repo, gh, tmp_path):
+    """AC1・AC8・I1: 承認ゲート 2 で止まるとき、最初の読みの先端を資料・metrics・gate の items に載せ、next が資料で照合する。"""
+    declare(repo, *TRYGROUP)
+    out_path = tmp_path / "approval-promote.md"
+    gh.set(create_number=9, pr_seq={"9": [dict(to("main", X), headRefName="develop"), dict(to("main", Y), headRefName="develop")]})
+    code, out, err = call("merged-steps.py", promote_args("--out", str(out_path)), gh.env, repo)
+    assert code == 10, (out, err)
+    assert approved_commit.material_sha(out_path) == X and out["metrics"]["approved_sha"] == X
+    assert next(i for i in out["items"] if i.get("result") == "gate")["head"] == X
+    assert f"--approved-from {out_path}" in out["next"] and merges(gh) == []
+
+
+def test_promote_gate_does_not_write_a_material_for_an_unreadable_head(repo, gh, tmp_path):
+    """I1: 先端が 40 桁の 16 進で読めなければ、資料を書かずに 2 で終える。"""
+    declare(repo, *TRYGROUP)
+    out_path = tmp_path / "approval-promote.md"
+    gh.set(create_number=9, pr_seq={"9": [dict(to("main", "a"), headRefName="develop")]})
+    code, out, err = call("merged-steps.py", promote_args("--out", str(out_path)), gh.env, repo)
+    assert code == 2 and out["status"] == "stopped", (out, err)
+    assert not out_path.exists() and merges(gh) == []
+
+
+def test_promote_approved_merges_the_approved_commit(repo, gh, tmp_path):
+    """AC2・I3: 資料が X・先端が X のまま CI が通れば、X に固定して 1 度だけマージする。"""
+    declare(repo, *TRYGROUP)
+    gh.set(open_prs=[{"number": 9}], pr_seq={"9": [dict(to("main", X), headRefName="develop")] * 3})
+    material = promote_material(tmp_path)
+    code, out, err = call("merged-steps.py", promote_args("--approved-from", str(material), "--gate-approved", "user"), gh.env, repo)
+    assert code == 0, (out, err)
+    assert merges(gh) == [["pr", "merge", "9", "--admin", "--merge", "--match-head-commit", X]]
+
+
+@pytest.mark.parametrize(
+    "seq",
+    [
+        [dict(to("main", Y), headRefName="develop")] * 2,  # 承認の前（か後）に進んだ
+        [dict(to("main", X), headRefName="develop"), dict(to("main", Y), headRefName="develop")],  # CI を待つ間に進んだ
+    ],
+)
+def test_promote_approved_stops_when_the_head_moved(repo, gh, tmp_path, seq):
+    """AC3・I3: 先端が承認したコミットと違えば、マージせずに head_moved で 1。next が承認ゲート 2 からのやり直しを示す。"""
+    declare(repo, *TRYGROUP)
+    gh.set(open_prs=[{"number": 9}], pr_seq={"9": seq})
+    material = promote_material(tmp_path)
+    code, out, err = call("merged-steps.py", promote_args("--approved-from", str(material), "--gate-approved", "user"), gh.env, repo)
+    assert code == 1 and out["status"] == "stopped", (out, err)
+    assert {"kind": "pr", "name": "#9", "result": "head_moved", "head": Y, "expected": X} in out["items"]
+    assert "--from promote" in out["next"] and merges(gh) == []
+
+
+@pytest.mark.parametrize(
+    "sha, row",
+    [(None, "承認したコミット"), (X, "確かめたコミット"), (X[:39], "承認したコミット"), ("z" * 40, "承認したコミット")],
+)
+def test_promote_approved_does_not_merge_without_a_readable_approved_commit(repo, gh, tmp_path, sha, row):
+    """AC4・I4: 資料が無い・欄が無い・40 桁の 16 進でなければ、gh を 1 度も呼ばずに 2 で止まる。"""
+    declare(repo, *TRYGROUP)
+    material = promote_material(tmp_path, sha, row)
+    code, out, err = call("merged-steps.py", promote_args("--approved-from", str(material), "--gate-approved", "user"), gh.env, repo)
+    assert code == 2 and out["status"] == "stopped", (out, err)
+    assert gh.get().get("calls", []) == []
+
+
+def test_promote_user_approval_needs_the_material(repo, gh):
+    """I5: --gate-approved user を --approved-from 無しで受けず、gh を 1 度も呼ばずに 2 で止まり、資料つきの打ち方を示す。"""
+    declare(repo, *TRYGROUP)
+    code, out, err = call("merged-steps.py", promote_args("--gate-approved", "user"), gh.env, repo)
+    assert code == 2 and out["status"] == "stopped", (out, err)
+    assert "--approved-from" in out["next"] and gh.get().get("calls", []) == []
diff --git a/plugins/ndf/scripts/tests/test_sprint_inputs.py b/plugins/ndf/scripts/tests/test_sprint_inputs.py
index 19b32bfa4..b9b1408e8 100644
--- a/plugins/ndf/scripts/tests/test_sprint_inputs.py
+++ b/plugins/ndf/scripts/tests/test_sprint_inputs.py
@@ -31,7 +31,7 @@ def sprint_args(tmp_path: Path, pace: str = "normal", issues=("11", "12"), desig
     args += ["--design", *design] if design else []
     args += ["--version", "10.18.0-dev.1", "--out", str(tmp_path / "m")]
     if pace != "normal":
-        args += ["--pace", pace, "--state", str(sprint_state(tmp_path))]
+        args += ["--pace", pace, "--state", str(sprint_state(tmp_path, "auto"))]
     return args, (repo if pace != "fast" else REPO)
 
 
diff --git a/plugins/ndf/scripts/tests/test_supervise_close_auto.py b/plugins/ndf/scripts/tests/test_supervise_close_auto.py
index 1fb832824..a3f877334 100644
--- a/plugins/ndf/scripts/tests/test_supervise_close_auto.py
+++ b/plugins/ndf/scripts/tests/test_supervise_close_auto.py
@@ -9,7 +9,7 @@ def close(tmp_path, *extra):
     out = tmp_path / "close"
     p = cli(
         "new", "close", "--name", "l1-1", "--worktree", str(tmp_path), "--issue", "11", "12",
-        "--version", "10.18.0-dev.2", "--prod", "10.18.0", "--state", str(sprint_state(tmp_path)), "--out", str(out), *extra,
+        "--version", "10.18.0-dev.2", "--prod", "10.18.0", "--state", str(sprint_state(tmp_path, "fast")), "--out", str(out), *extra,
     )  # fmt: skip
     assert p.returncode == 0, p.stdout + p.stderr
     return load(out / "sprint.json")
diff --git a/plugins/ndf/scripts/tests/test_supervise_new.py b/plugins/ndf/scripts/tests/test_supervise_new.py
index db1633103..f8ced6dc6 100644
--- a/plugins/ndf/scripts/tests/test_supervise_new.py
+++ b/plugins/ndf/scripts/tests/test_supervise_new.py
@@ -694,10 +694,10 @@ def test_plan_promote_with_mvv_judges_before_merging(tmp_path):
     （--gate-approved mvv）。note か promote が落ちたら handoff が承認ゲートへ落とす。"""
     import argparse
 
-    from supervise_lib.delivery_templates import plan_promote
+    from supervise_lib.delivery_templates import PromoteParams, plan_promote
 
     a = argparse.Namespace(base="develop", production_branch="main", issue=[1], mode="standard", no_reports="")
-    plan = plan_promote(a, str(tmp_path), 600, mvv=str(tmp_path / "s.json"), verify="true")
+    plan = plan_promote(a, str(tmp_path), 600, PromoteParams(mvv=str(tmp_path / "s.json"), verify="true"))
     steps = {s["id"]: s for s in plan["steps"]}
     assert [s["id"] for s in plan["steps"]][:5] == ["verify", "prepare", "mvv", "note", "promote"]
     assert "--prepare --out" in steps["prepare"]["cmd"] and steps["mvv"]["gate_next"] == "end"
diff --git a/plugins/ndf/scripts/tests/test_supervise_pace.py b/plugins/ndf/scripts/tests/test_supervise_pace.py
index 85e9b8646..e27bc1f90 100644
--- a/plugins/ndf/scripts/tests/test_supervise_pace.py
+++ b/plugins/ndf/scripts/tests/test_supervise_pace.py
@@ -17,13 +17,15 @@
 
 SCRIPTS = Path(__file__).resolve().parents[1]
 SUPERVISE = SCRIPTS / "supervise.py"
-SPRINT_STATE = SCRIPTS / "sprint-state.py"
 REPO = SCRIPTS.parents[2]
 PY = sys.executable
 
 sys.path.insert(0, str(SCRIPTS))
 from supervise_lib import engine, flow, paths, queue  # noqa: E402
 
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from pace_state import sprint_state  # noqa: E402
+
 
 # new sprint は --design に無い課題の本文を gh で読む（#1767）。見本の本文で答える
 pytestmark = pytest.mark.usefixtures("issue_bodies")
@@ -33,20 +35,6 @@ def cli(*args, cwd=None):
     return subprocess.run([PY, str(SUPERVISE), *args], capture_output=True, text=True, cwd=cwd or REPO)
 
 
-def sprint_state(tmp_path: Path, approve: bool = True) -> Path:
-    mvv = tmp_path / "mvv-src.md"
-    mvv.write_text("## Mission\n速く\n## Vision\n回る\n## Value\n実測\n")
-    state = tmp_path / "state" / "sprint-state.json"
-    subprocess.run(
-        [PY, str(SPRINT_STATE), "init", str(state), "--name", "m", "--pace", "fast", "--mvv", str(mvv), "--root", str(tmp_path)],
-        check=True,
-        capture_output=True,
-    )
-    if approve:
-        subprocess.run([PY, str(SPRINT_STATE), "gate", str(state), "MVV", "--what", "MVV を承認"], check=True, capture_output=True)
-    return state
-
-
 def load(path) -> dict:
     return json.loads(Path(path).read_text())
 
@@ -94,7 +82,7 @@ def new_fast_sprint(tmp_path, state, *extra):
 
 
 def test_fast_sprint_puts_check_then_dev_then_prod_after_the_implementation(tmp_path):
-    p, out = new_fast_sprint(tmp_path, sprint_state(tmp_path))
+    p, out = new_fast_sprint(tmp_path, sprint_state(tmp_path, "fast"))
     assert p.returncode == 0, p.stdout + p.stderr
     manifest = load(out / "sprint.json")
     assert manifest["進め方"] == "fast" and manifest["状態"].endswith("sprint-state.json")
@@ -158,7 +146,7 @@ def approve_runs_with_or_without_note(tmp_path, cmd):
 
 @pytest.mark.parametrize("change", ["unapproved", "changed"])
 def test_fast_sprint_is_refused_without_a_matching_approval(tmp_path, change):
-    state = sprint_state(tmp_path, approve=change != "unapproved")
+    state = sprint_state(tmp_path, "fast", approve=change != "unapproved")
     if change == "changed":
         mvv = Path(load(state)["mvv"]["path"])
         mvv.write_text(mvv.read_text() + "足した行\n")
@@ -169,7 +157,7 @@ def test_fast_sprint_is_refused_without_a_matching_approval(tmp_path, change):
 
 
 def test_fast_sprint_is_refused_for_operation_mode(tmp_path):
-    p, out = new_fast_sprint(tmp_path, sprint_state(tmp_path), "--mode", "operation")
+    p, out = new_fast_sprint(tmp_path, sprint_state(tmp_path, "fast"), "--mode", "operation")
     assert p.returncode == 1 and "モード" in json.loads(p.stdout)["summary"]
 
 
@@ -193,7 +181,7 @@ def test_fast_sprint_is_refused_without_the_declaration(tmp_path):
         "--pace",
         "fast",
         "--state",
-        str(sprint_state(tmp_path)),
+        str(sprint_state(tmp_path, "fast")),
         "--out",
         str(out),
         cwd=repo,
@@ -320,7 +308,7 @@ def test_close_runs_spec_close_and_retro_once_each_in_order(tmp_path):
         "--prod",
         "10.18.0",
         "--state",
-        str(sprint_state(tmp_path)),
+        str(sprint_state(tmp_path, "fast")),
         "--out",
         str(out),
     )
@@ -359,7 +347,7 @@ def test_close_runs_spec_close_and_retro_once_each_in_order(tmp_path):
 
 
 def test_release_with_mvv(tmp_path):
-    state = sprint_state(tmp_path)
+    state = sprint_state(tmp_path, "fast")
     for channel, version in (("prod", "10.18.0"), ("dev", "10.18.0-dev.1")):
         out = tmp_path / f"{channel}.json"
         p = cli(
diff --git a/plugins/ndf/scripts/tests/test_supervise_pace_auto.py b/plugins/ndf/scripts/tests/test_supervise_pace_auto.py
index 09d72875b..7c6508cfd 100644
--- a/plugins/ndf/scripts/tests/test_supervise_pace_auto.py
+++ b/plugins/ndf/scripts/tests/test_supervise_pace_auto.py
@@ -23,6 +23,9 @@
 sys.path.insert(0, str(SCRIPTS))
 from supervise_lib import queue  # noqa: E402
 
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from pace_state import sprint_state  # noqa: E402
+
 AUTO = {"enabled": True, "modes": ["light", "standard", "legacy-refactor"], "verify": "true"}
 STAGES = ["設計", "関門 1", "設計の結果", "スプリントブランチ", "実装", "検査", "開発版", "本番"]
 
@@ -39,20 +42,6 @@ def steps_of(plan: dict) -> dict:
     return {s["id"]: s for s in plan["steps"]}
 
 
-def sprint_state(tmp_path: Path, approve: bool = True) -> Path:
-    mvv = tmp_path / "mvv-src.md"
-    mvv.write_text("## Mission\n速く\n## Vision\n回る\n## Value\n実測\n")
-    state = tmp_path / "state" / "sprint-state.json"
-    subprocess.run(
-        [PY, str(SPRINT_STATE), "init", str(state), "--name", "m", "--pace", "auto", "--mvv", str(mvv), "--root", str(tmp_path)],
-        check=True,
-        capture_output=True,
-    )
-    if approve:
-        subprocess.run([PY, str(SPRINT_STATE), "gate", str(state), "MVV", "--what", "MVV を承認"], check=True, capture_output=True)
-    return state
-
-
 def make_repo(tmp_path: Path, pace: dict | None, prod: str = "main", form: bool = True) -> Path:
     """宣言だけを持つリポジトリ。pace は pace.json の中身（None なら置かない）。"""
     repo = tmp_path / "repo"
@@ -82,14 +71,14 @@ def new_sprint(tmp_path, repo, state, *extra, pace="auto", design=True):
 def test_designed_issues_get_a_design_results_stage_without_designing(tmp_path):
     """設計を承認済みの課題（--designed）は設計を作らず、設計の結果のステージで読んで実装へ渡す（#2089 の loop answer）。"""
     repo = make_repo(tmp_path, {"auto": AUTO})
-    p, out = new_sprint(tmp_path, repo, sprint_state(tmp_path), "--designed", "12", design=False)
+    p, out = new_sprint(tmp_path, repo, sprint_state(tmp_path, "auto"), "--designed", "12", design=False)
     assert p.returncode == 0, p.stdout + p.stderr
     waves = {w["name"]: w for w in load(out / "sprint.json")["ステージ"]}
     assert "設計" not in waves and "関門 1" not in waves and "command" in waves["設計の結果"]
     assert all(w.get("then_of") == "設計の結果" for n, w in waves.items() if n != "設計の結果")
     cmd = steps_of(load(waves["設計の結果"]["plans"][0]))["design-results"]["cmd"]
     assert cmd.endswith("--design 12")
-    p, out = new_sprint(tmp_path, repo, sprint_state(tmp_path), "--designed", "12")
+    p, out = new_sprint(tmp_path, repo, sprint_state(tmp_path, "auto"), "--designed", "12")
     waves = {w["name"]: w for w in load(out / "sprint.json")["ステージ"]}
     assert waves["設計"]["plans"][0].endswith("design-11.json") and len(waves["設計"]["plans"]) == 1
     assert steps_of(load(waves["設計の結果"]["plans"][0]))["design-results"]["cmd"].endswith("--design 11 12")
@@ -97,7 +86,7 @@ def test_designed_issues_get_a_design_results_stage_without_designing(tmp_path):
 
 def test_auto_sprint_writes_the_normal_order_with_mvv_gates(tmp_path):
     repo = make_repo(tmp_path, {"auto": AUTO})
-    p, out = new_sprint(tmp_path, repo, sprint_state(tmp_path))
+    p, out = new_sprint(tmp_path, repo, sprint_state(tmp_path, "auto"))
     assert p.returncode == 0, p.stdout + p.stderr
     manifest = load(out / "sprint.json")
     assert manifest["進め方"] == "auto" and manifest["ブランチ"] == "sprint/m27" and manifest["状態"].endswith("sprint-state.json")
@@ -149,7 +138,7 @@ def test_auto_sprint_writes_the_normal_order_with_mvv_gates(tmp_path):
 )
 def test_auto_is_refused_when_the_declaration_does_not_allow_it(tmp_path, pace, word):
     repo = make_repo(tmp_path, pace)
-    p, out = new_sprint(tmp_path, repo, sprint_state(tmp_path))
+    p, out = new_sprint(tmp_path, repo, sprint_state(tmp_path, "auto"))
     res = json.loads(p.stdout)
     assert p.returncode == 1 and res["status"] == "stopped" and word in res["summary"], res
     assert "--pace" not in res["next"] and "new sprint" in res["next"] and not out.exists()
@@ -158,7 +147,7 @@ def test_auto_is_refused_when_the_declaration_does_not_allow_it(tmp_path, pace,
 def test_the_normal_fallback_keeps_every_sprint_option(tmp_path):
     repo = make_repo(tmp_path, None)
     extra = ["--test-cmd", "pytest {paths}", "--tests", "a", "b", "--scope", "s", "--base", "dev2", "--production-branch", "prd"]
-    p, _ = new_sprint(tmp_path, repo, sprint_state(tmp_path), *extra)
+    p, _ = new_sprint(tmp_path, repo, sprint_state(tmp_path, "auto"), *extra)
     nxt = json.loads(p.stdout)["next"]
     assert "--pace" not in nxt and "--state" not in nxt
     for part in ["--test-cmd 'pytest {paths}'", "--tests a b", "--scope s", "--base dev2", "--production-branch prd", "--design 11"]:
@@ -167,19 +156,19 @@ def test_the_normal_fallback_keeps_every_sprint_option(tmp_path):
 
 def test_auto_is_refused_for_operation_mode_without_a_dev_channel_and_without_mvv(tmp_path):
     repo = make_repo(tmp_path, {"auto": {**AUTO, "modes": ["operation", "standard"]}})
-    p, _ = new_sprint(tmp_path, repo, sprint_state(tmp_path), "--mode", "operation")
+    p, _ = new_sprint(tmp_path, repo, sprint_state(tmp_path, "auto"), "--mode", "operation")
     assert p.returncode == 1 and "モード operation" in json.loads(p.stdout)["summary"]
     repo2 = make_repo(tmp_path / "b", {"auto": AUTO}, prod="develop")
-    p, _ = new_sprint(tmp_path / "b", repo2, sprint_state(tmp_path / "b"))
+    p, _ = new_sprint(tmp_path / "b", repo2, sprint_state(tmp_path / "b", "auto"))
     assert p.returncode == 1 and "開発版のチャネル" in json.loads(p.stdout)["summary"]
     repo3 = make_repo(tmp_path / "c", {"auto": AUTO})
-    p, out = new_sprint(tmp_path / "c", repo3, sprint_state(tmp_path / "c", approve=False))
+    p, out = new_sprint(tmp_path / "c", repo3, sprint_state(tmp_path / "c", "auto", approve=False))
     assert p.returncode == 1 and json.loads(p.stdout)["status"] == "stopped" and not out.exists()
 
 
 def test_the_fast_and_auto_sections_do_not_stand_in_for_each_other(tmp_path):
     repo = make_repo(tmp_path, {"auto": AUTO})
-    p, _ = new_sprint(tmp_path, repo, sprint_state(tmp_path), pace="fast")
+    p, _ = new_sprint(tmp_path, repo, sprint_state(tmp_path, "auto"), pace="fast")
     assert p.returncode == 1 and "fast.enabled" in json.loads(p.stdout)["summary"]
 
 
@@ -188,7 +177,7 @@ def test_the_fast_and_auto_sections_do_not_stand_in_for_each_other(tmp_path):
 
 def test_without_design_the_sprint_branch_carries_the_command(tmp_path):
     repo = make_repo(tmp_path, {"auto": AUTO})
-    p, out = new_sprint(tmp_path, repo, sprint_state(tmp_path), design=False)
+    p, out = new_sprint(tmp_path, repo, sprint_state(tmp_path, "auto"), design=False)
     assert p.returncode == 0, p.stdout + p.stderr
     waves = load(out / "sprint.json")["ステージ"]
     assert [w["name"] for w in waves] == STAGES[3:]
@@ -197,7 +186,7 @@ def test_without_design_the_sprint_branch_carries_the_command(tmp_path):
 
 def test_without_a_release_template_the_last_stage_is_manual(tmp_path):
     repo = make_repo(tmp_path, {"auto": AUTO}, form=False)
-    p, out = new_sprint(tmp_path, repo, sprint_state(tmp_path))
+    p, out = new_sprint(tmp_path, repo, sprint_state(tmp_path, "auto"))
     assert p.returncode == 0, p.stdout + p.stderr
     waves = load(out / "sprint.json")["ステージ"]
     assert [w["name"] for w in waves] == [*STAGES[:6], "リリース"] and "manual" in waves[-1]
@@ -218,7 +207,7 @@ def gate_mvv(state: Path, gate: str, log: Path) -> None:
 
 def auto_plans(tmp_path) -> tuple[Path, dict]:
     repo = make_repo(tmp_path, {"auto": AUTO})
-    state = sprint_state(tmp_path)
+    state = sprint_state(tmp_path, "auto")
     p, out = new_sprint(tmp_path, repo, state)
     assert p.returncode == 0, p.stdout + p.stderr
     return state, {w["name"]: w for w in load(out / "sprint.json")["ステージ"]}
@@ -262,7 +251,7 @@ def test_a_failed_merge_after_a_follow_verdict_ends_in_a_gate_and_withdraws_the_
 
 def test_a_rejection_after_an_automatic_pass_is_an_override(tmp_path, monkeypatch):
     monkeypatch.setenv("NDF_MVV_STATE_DIR", str(tmp_path / "mvv-state"))
-    state = sprint_state(tmp_path)
+    state = sprint_state(tmp_path, "auto")
     gate_mvv(state, "関門 2", tmp_path / "mvv-gate.jsonl")
     p = subprocess.run(
         [PY, str(SPRINT_STATE), "gate", str(state), "関門 2", "--what", "差し戻し", "--outcome", "rejected"]
@@ -276,7 +265,7 @@ def test_a_rejection_after_an_automatic_pass_is_an_override(tmp_path, monkeypatc
 
 
 def test_withdraw_keeps_the_user_record_and_does_nothing_without_a_record(tmp_path):
-    state = sprint_state(tmp_path)
+    state = sprint_state(tmp_path, "auto")
     p = subprocess.run([PY, str(SPRINT_STATE), "gate", str(state), "関門 1", "--withdraw"], capture_output=True, text=True)
     assert p.returncode == 0 and json.loads(p.stdout)["metrics"]["withdrawn"] == 0
     assert [w["name"] for w in load(state)["withdrawals"]] == ["関門 1"]
@@ -289,7 +278,7 @@ def test_withdraw_keeps_the_user_record_and_does_nothing_without_a_record(tmp_pa
 
 def test_a_parallel_design_plan_cannot_revive_a_withdrawn_gate(tmp_path):
     """並列の設計プラン: 片方の handoff が先に取り消したら、もう片方が後から書く by: mvv は断られる（#1383 の指摘）。"""
-    state = sprint_state(tmp_path)
+    state = sprint_state(tmp_path, "auto")
     p = subprocess.run([PY, str(SPRINT_STATE), "gate", str(state), "関門 1", "--withdraw"], capture_output=True, text=True)
     assert p.returncode == 0
     p = subprocess.run(
diff --git a/plugins/ndf/scripts/tests/test_supervise_pace_manual.py b/plugins/ndf/scripts/tests/test_supervise_pace_manual.py
index 7694d6a20..1f135d39f 100644
--- a/plugins/ndf/scripts/tests/test_supervise_pace_manual.py
+++ b/plugins/ndf/scripts/tests/test_supervise_pace_manual.py
@@ -49,7 +49,7 @@ def make_repo(tmp_path: Path, rows, verify: str = "echo stack-ok") -> Path:
 def new_sprint(tmp_path, repo, pace="auto"):
     out = tmp_path / "m"
     args = ["new", "sprint", "--name", "m2", "--worktree", str(repo), "--issue", "11", "--design", "11"]
-    args += ["--pace", pace, "--state", str(sprint_state(tmp_path)), "--out", str(out)]
+    args += ["--pace", pace, "--state", str(sprint_state(tmp_path, "auto")), "--out", str(out)]
     p = subprocess.run([PY, str(SUPERVISE), *args], capture_output=True, text=True, cwd=repo)
     return p, out
 
@@ -236,7 +236,7 @@ def test_separate_branches_keep_their_stages(tmp_path, form):
     if not form:
         rows = [{**STG, "branch": "develop"}, PRD]
         (repo / ".ndf" / "project.json").write_text(json.dumps({"delivery": rows}))
-    p, out = pa.new_sprint(tmp_path, repo, pa.sprint_state(tmp_path))
+    p, out = pa.new_sprint(tmp_path, repo, pa.sprint_state(tmp_path, "auto"))
     assert p.returncode == 0, p.stdout + p.stderr
     manifest = load(out / "sprint.json")
     names = [w["name"] for w in manifest["ステージ"]]
diff --git a/plugins/ndf/scripts/tests/test_supervise_pace_verify.py b/plugins/ndf/scripts/tests/test_supervise_pace_verify.py
index a8164ed53..90de1fe16 100644
--- a/plugins/ndf/scripts/tests/test_supervise_pace_verify.py
+++ b/plugins/ndf/scripts/tests/test_supervise_pace_verify.py
@@ -52,7 +52,7 @@ def new_sprint(tmp_path, repo, pace: str | None = "auto"):
     out = tmp_path / "m"
     args = ["new", "sprint", "--name", "m2", "--worktree", str(repo), "--issue", "11", "--out", str(out)]
     if pace:
-        args += ["--pace", pace, "--state", str(sprint_state(tmp_path))]
+        args += ["--pace", pace, "--state", str(sprint_state(tmp_path, "auto"))]
     p = subprocess.run([PY, str(SUPERVISE), *args], capture_output=True, text=True, cwd=repo)
     assert p.returncode == 0, p.stdout + p.stderr
     return load(out / "sprint.json")["ステージ"]
@@ -60,7 +60,7 @@ def new_sprint(tmp_path, repo, pace: str | None = "auto"):
 
 def new_close(tmp_path, repo):
     out = tmp_path / "c"
-    args = ["new", "close", "--name", "m2", "--worktree", str(repo), "--issue", "11", "--state", str(sprint_state(tmp_path))]
+    args = ["new", "close", "--name", "m2", "--worktree", str(repo), "--issue", "11", "--state", str(sprint_state(tmp_path, "auto"))]
     p = subprocess.run([PY, str(SUPERVISE), *args, "--out", str(out)], capture_output=True, text=True, cwd=repo)
     return p, out
 
@@ -123,15 +123,19 @@ def test_the_promote_merges_only_the_commit_the_mvv_judge_read(tmp_path, pace):
 
 
 def test_the_promote_plan_uses_the_declared_branch_names(tmp_path):
-    """#1529 の AC7・AC8・I5: 照合の引数は fast / auto の promote にだけ付き、ブランチ名は引数のものだけが現れる。"""
-    from supervise_lib.delivery_templates import plan_promote
+    """#1529 の AC7・AC8・I5: 確かめたコミットの照合は fast / auto の promote にだけ付き、ブランチ名は引数のものだけが現れる。
+    #2104 の AC5・I7: normal の promote は昇格の承認資料を書き、両方の promote-approved が同じ資料で照合する。"""
+    from supervise_lib.delivery_templates import PromoteParams, plan_promote
 
     a = type("A", (), {"base": "trunk", "production_branch": "stable", "issue": "11", "mode": "standard"})()
-    normal = steps_of(plan_promote(a, str(tmp_path), 600, verify="true"))
-    fast = steps_of(plan_promote(a, str(tmp_path), 600, mvv=str(tmp_path / "state.json"), verify="true"))
+    normal = steps_of(plan_promote(a, str(tmp_path), 600, PromoteParams(verify="true")))
+    fast = steps_of(plan_promote(a, str(tmp_path), 600, PromoteParams(mvv=str(tmp_path / "state.json"), verify="true")))
     base = f"{SCRIPTS / 'merged-steps.py'} promote --head trunk --base stable --timeout 600"
-    assert normal["promote"]["cmd"].endswith(base) and normal["promote-approved"]["cmd"].endswith(base + " --gate-approved user")
+    promote_material = "{state_dir}/work/approval-promote.md"
+    assert normal["promote"]["cmd"].endswith(base + f" --out {promote_material}")
+    assert normal["promote-approved"]["cmd"].endswith(base + f" --approved-from {promote_material} --gate-approved user")
     assert fast["promote-approved"]["cmd"] == normal["promote-approved"]["cmd"]
+    assert fast["prepare"]["cmd"].endswith(f"--prepare --out {promote_material}")  # #2104 の AC5・I7: 書き手と読み手が同じ資料
     want = base + " --expect-head-from {state_dir}/work/approval-verify.md --gate-approved mvv"
     assert fast["promote"]["cmd"].endswith(want)
     for s in (*normal.values(), *fast.values()):
@@ -142,7 +146,7 @@ def test_a_promote_without_the_verified_commit_falls_back_to_gate_2(tmp_path):
     """#1529 の AC4・AC5: 導入の確認の承認資料が無ければ、plan の promote はマージせずに落ち、handoff が
     承認ゲート 2 の by: mvv の記録を外して承認ゲートで終わる。"""
     repo = make_repo(tmp_path, [STG, PRD])
-    state = sprint_state(tmp_path)
+    state = sprint_state(tmp_path, "auto")
     plan = load(wave(new_sprint(tmp_path, repo), "本番")["plans"][0])
     log = tmp_path / "mvv-gate.jsonl"
     stub = {
@@ -263,7 +267,7 @@ def test_gate_2_and_the_template_keep_their_stages(tmp_path):
     assert facts["timeout"] == 1500 and facts["cwd"] == repo and facts["stage"] == "配布" and facts["next"] == "mvv"
     assert "deploy-facts --root" in facts["cmd"] and "--out {state_dir}/work/approval-deploy.md" in facts["cmd"]
     repo = pa.make_repo(tmp_path / "t", {"auto": pa.AUTO}, form=True)
-    p, out = pa.new_sprint(tmp_path / "t", repo, pa.sprint_state(tmp_path / "t"))
+    p, out = pa.new_sprint(tmp_path / "t", repo, pa.sprint_state(tmp_path / "t", "auto"))
     assert p.returncode == 0, p.stdout + p.stderr
     waves = load(out / "sprint.json")["ステージ"]
     assert [w["name"] for w in waves] == pa.STAGES and verify_steps(waves) == []
diff --git a/plugins/ndf/skills/development-workflow/references/pace.md b/plugins/ndf/skills/development-workflow/references/pace.md
index 806394f96..3adf3a4cc 100644
--- a/plugins/ndf/skills/development-workflow/references/pace.md
+++ b/plugins/ndf/skills/development-workflow/references/pace.md
@@ -232,7 +232,10 @@ glob の `**` は区切りをまたぎ、`*` と `?` はまたがない。どの
 `approval-verify.md` を `--expect-head-from` に受け、そこに書かれた確かめたコミット（導入の確認を走らせたベースブランチの先頭）が
 昇格の Pull Request の先端のときだけマージする。確認の後にベースブランチが進んで先端が違えば（CI を待つ間に進んだときも）
 `gh pr merge` を呼ばずに `head_moved` で 1、資料から確かめたコミットを読めなければマージせずに 2 で止まり、どちらも `handoff` が
-承認ゲート 2 の `by: mvv` の記録を外して承認ゲートへ落とす。`fast` / `auto` の `merge` の経路では開発版のステージを置かない
+承認ゲート 2 の `by: mvv` の記録を外して承認ゲートへ落とす。`normal` の `promote` は承認ゲート 2 で止まるときに昇格の
+Pull Request の先端を「承認したコミット」として昇格の承認資料（`approval-promote.md`。`fast` / `auto` では `prepare` が書く）へ載せ、
+`promote-approved` は `pace` のどれでもその資料の承認したコミットが先端のときだけマージする。先端が違えば `head_moved` で 1、
+資料から読めなければ 2 で、マージせずに止まる。`fast` / `auto` の `merge` の経路では開発版のステージを置かない
 （ベースブランチへのマージが検証への反映である）。
 
 **`fast` / `auto` の `merge` の経路では、導入の確認（`<節>.verify`）を 1 つのスプリントの中で 1 度だけ走らせる。** 昇格のプランが
@@ -264,7 +267,7 @@ glob の `**` は区切りをまたぎ、`*` と `?` はまたがない。どの
 | 答え | 打つもの |
 | --- | --- |
 | 承認（ゲート 1） | `sprint-state.py gate <状態> "関門 1" --what <要約> --by user --outcome approved` → `supervise.py run <設計のプラン> --from approve` → マニフェストのスプリントブランチのステージの `resume` |
-| 承認（ゲート 2） | `sprint-state.py gate <状態> "関門 2" --what <要約> --by user --outcome approved` → `supervise.py run <本番のプラン> --from bump`（昇格のプランは `--from promote-approved`。ただし `promote` が照合で止まった（`head_moved`・確かめたコミットを読めない）ときは `--from verify` から流し直す。`promote-approved` は照合を持たず、導入の確認も MVV 判定もしていない今の先端をマージする。マージの `merge-gate` で止まったプランは `--from merge-approved`。`gate-2` のプランは続きを流さず、手で行う「本番」のステージへ進む） |
+| 承認（ゲート 2） | `sprint-state.py gate <状態> "関門 2" --what <要約> --by user --outcome approved` → `supervise.py run <本番のプラン> --from bump`（昇格のプランは `--from promote-approved`。ただし `promote` が照合で止まった（`head_moved`・確かめたコミットを読めない）ときは `--from verify` から流し直す。`promote-approved` が照合で止まった（`head_moved`・承認したコミットを読めない）ときは、`normal` は `--from promote` から流し直して新しい先端で承認ゲート 2 を取り直し、`fast` / `auto` は `--from verify` から流し直す。マージの `merge-gate` で止まったプランは `--from merge-approved`。`gate-2` のプランは続きを流さず、手で行う「本番」のステージへ進む） |
 | 差し戻し | `sprint-state.py gate <状態> "関門 N" --what <要約> --by user --outcome rejected`。続きは流さない。差し戻しは状態ファイルでなく差し戻しの記録（`gate-rejections.jsonl`）へ 1 行残る。状態ファイルの無い進め方の打ち方は [approval-request.md](approval-request.md) の「答えを記録する」 |
 
 **判定と食い違う答えは覆しとして残る。** 「従う」で自動に通った後の差し戻しは `override_reject`、「従わない」「判定できない」で
diff --git a/scripts/build-runtime-plugins.sh b/scripts/build-runtime-plugins.sh
index d0afd9849..3344d3f76 100755
--- a/scripts/build-runtime-plugins.sh
+++ b/scripts/build-runtime-plugins.sh
@@ -9,8 +9,8 @@ usage() {
 Usage: bash scripts/build-runtime-plugins.sh [--check]
 
 Generate the tracked build outputs: Codex implicit-invocation policies for
-single-directory plugins, the agy skill links under dev.agy/, and the runtime
-copies of MCP plugins.
+single-directory plugins, the agy skill links and agent definitions under
+dev.agy/, and the runtime copies of MCP plugins.
 
 Options:
   --check   Compare generated output with the working tree and fail on drift.
@@ -41,7 +41,8 @@ sync_codex_skill_policies() {
 # agy は配る Skill を絞る手段を利用者側の設定にしか持たない（`plugins.json` の絞り込みは
 # プラグインのディレクトリ名に掛かり、同梱の Skill には届かない）。そこで絞り込みは
 # dev.agy/skills/ へ何を並べるかで表す。並べる内容は manifests/agy-skills.txt が決める。
-# エージェント定義と hook の実体は 4 ランタイムで共有するため、同じ位置へ symlink を張る。
+# hook の実体は 4 ランタイムで共有するため、同じ位置へ symlink を張る。エージェント定義は
+# agy の受け付ける `model` へ変えた写しを置く（sync_agy_agents）。
 # Agent Plugins 仕様 §8.2 のクライアント拡張ディレクトリに当たる。
 sync_agy_skill_links() {
   local family="$1"
@@ -63,17 +64,15 @@ published = [
     if line.split("#", 1)[0].strip()
 ]
 
-# 生成する symlink と、その向き先。skills/ は基準が決め、agents と scripts は固定である。
+# 生成する symlink と、その向き先。skills/ は基準が決め、scripts は固定である。
 expected = {links_dir / name: f"../../skills/{name}" for name in published}
-expected.update({dev_dir / "agents": "../agents", dev_dir / "scripts": "../scripts"})
+expected.update({dev_dir / "scripts": "../scripts"})
 
 actual = set()
 if links_dir.is_dir():
     actual |= set(links_dir.iterdir())
-for name in ("agents", "scripts"):
-    path = dev_dir / name
-    if path.is_symlink():
-        actual.add(path)
+if (dev_dir / "scripts").is_symlink():
+    actual.add(dev_dir / "scripts")
 stale = sorted(actual - set(expected))
 
 failed = False
@@ -288,6 +287,16 @@ EOF
   chmod +x "$installer"
 }
 
+# agy 1.4 系は `model` に tier 名しか受け付けないため、エージェント定義は symlink で共有せず、
+# `model` だけを tier 名へ変えた写しを dev.agy/agents/ へ置く（#2087）。
+sync_agy_agents() {
+  local family="$1"
+  local plugin_dir="$ROOT_DIR/plugins/$family"
+
+  [ -d "$plugin_dir/dev.agy" ] || return 0
+  python3 "$ROOT_DIR/scripts/lib/agy_agents.py" "$plugin_dir" "$CHECK"
+}
+
 sync_mcp_plugins() {
   local plugin_dir
 
@@ -305,6 +314,7 @@ for dir in "$ROOT_DIR"/plugins/*; do
   esac
   sync_codex_skill_policies "$family"
   sync_agy_skill_links "$family"
+  sync_agy_agents "$family"
 done
 
 sync_mcp_plugins
diff --git a/scripts/lib/agy_agents.py b/scripts/lib/agy_agents.py
new file mode 100644
index 000000000..ce1e36be0
--- /dev/null
+++ b/scripts/lib/agy_agents.py
@@ -0,0 +1,167 @@
+#!/usr/bin/env python3
+"""agy に配るエージェント定義（`dev.agy/agents/*.md`）を生成・確認する（`scripts/build-runtime-plugins.sh` の一部）。
+
+agy 1.4 系はエージェント定義の `model` に tier 名（`flash` / `pro` / `inherit`）しか受け付けず、
+Claude Code の型の名前（`sonnet` / `opus`）を持つ定義を読み飛ばす（#2087）。そこで `agents/*.md` を写し、
+frontmatter の `model:` の 1 行だけを対応表で tier 名へ置き換える。YAML として読み直さないのは、
+写しと元の差を `model:` の 1 行に限ってバイト列で確かめるためである（設計の決定 3）。
+
+    python3 scripts/lib/agy_agents.py <plugin ディレクトリ> <true|false>
+
+2 つ目が `true` なら書かずに確かめ、食い違いを標準エラーに出して終了コード 1 で終わる。
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+# agy 1.4 系が `model` に受け付ける tier 名。欄が無いときは agy の既定（`inherit`）になる。
+AGY_TIERS = frozenset({"flash", "pro", "inherit"})
+
+# Claude Code の型の名前 → agy の tier 名。安い型は安い tier へ、高い型は高い tier へ写す（設計の決定 2）。
+# ここに無い値は生成を止める（設計の決定 4）。足すときは 1 行足す。
+MODEL_MAP = {
+    "sonnet": "flash",
+    "opus": "pro",
+    "haiku": "flash",
+    "inherit": "inherit",
+}
+
+
+class UnknownModel(Exception):
+    """対応表に無い `model` の値。"""
+
+
+def model_value(line: str) -> str:
+    """`model: <値>` の行から値を取り出す（引用符は外す）。"""
+    value = line.split(":", 1)[1].strip()
+    if len(value) >= 2 and value[0] == value[-1] and value[0] in "'\"":
+        value = value[1:-1]
+    return value
+
+
+def _model_line_index(lines: list[str]) -> int | None:
+    """frontmatter の `model:` の行の添字。frontmatter か欄が無ければ None（行末の改行の有無は問わない）。"""
+    if not lines or lines[0].strip() != "---":
+        return None
+    for index, line in enumerate(lines[1:], start=1):
+        if line.strip() == "---":
+            return None
+        if line.startswith("model:"):
+            return index
+    return None
+
+
+def frontmatter_model(text: str) -> str | None:
+    """frontmatter の `model` の値。欄が無ければ None。"""
+    lines = text.splitlines()
+    index = _model_line_index(lines)
+    return None if index is None else model_value(lines[index])
+
+
+def agy_copy(text: str, model_map: dict[str, str]) -> str:
+    """frontmatter の `model:` の 1 行だけを tier 名へ置き換えた写し。欄が無ければそのまま返す。"""
+    lines = text.splitlines(keepends=True)
+    index = _model_line_index(lines)
+    if index is None:
+        return text
+    line = lines[index]
+    value = model_value(line)
+    if value not in model_map:
+        raise UnknownModel(value)
+    ending = line[len(line.rstrip("\r\n")) :]
+    lines[index] = f"model: {model_map[value]}{ending}"
+    return "".join(lines)
+
+
+def map_errors(model_map: dict[str, str]) -> list[str]:
+    """対応表の値のうち tier 名でないもの。"""
+    return [f"Model map value is not an agy tier: {key}: {value}" for key, value in sorted(model_map.items()) if value not in AGY_TIERS]
+
+
+def sync(plugin_dir: Path, check: bool, model_map: dict[str, str] | None = None) -> bool:
+    """生成物を書く（`check` なら確かめる）。食い違いがあれば偽。"""
+    model_map = MODEL_MAP if model_map is None else model_map
+    dev_dir = plugin_dir / "dev.agy"
+    source_dir = plugin_dir / "agents"
+    if not dev_dir.is_dir():
+        return True
+    root = plugin_dir.resolve().parents[1]
+
+    def rel(path: Path) -> str:
+        try:
+            return str(path.relative_to(root))
+        except ValueError:
+            return str(path)
+
+    errors = map_errors(model_map)
+    for message in errors:
+        print(message, file=sys.stderr)
+    if errors:
+        return False
+
+    out_dir = dev_dir / "agents"
+    expected = _expected_copies(source_dir, out_dir, model_map, rel)
+    if expected is None:
+        return False
+    if check:
+        return _check_copies(out_dir, expected, rel)
+    _write_copies(out_dir, expected)
+    return True
+
+
+def _expected_copies(source_dir: Path, out_dir: Path, model_map: dict[str, str], rel) -> dict[Path, str] | None:
+    """写しの置き場 → 中身。対応表に無い `model` があれば標準エラーに出して None。"""
+    sources = sorted(source_dir.glob("*.md")) if source_dir.is_dir() else []
+    expected: dict[Path, str] = {}
+    ok = True
+    for source in sources:
+        text = source.read_text(encoding="utf-8")
+        try:
+            expected[out_dir / source.name] = agy_copy(text, model_map)
+        except UnknownModel as exc:
+            print(f"Unknown model for agy: {rel(source)}: {exc}", file=sys.stderr)
+            ok = False
+    return expected if ok else None
+
+
+def _check_copies(out_dir: Path, expected: dict[Path, str], rel) -> bool:
+    """書かずに確かめる。食い違いを標準エラーに出し、あれば偽。"""
+    if out_dir.is_symlink():
+        print(f"Generated agents must be files, not a symlink: {rel(out_dir)}", file=sys.stderr)
+        return False
+    ok = True
+    actual = {p for p in out_dir.iterdir()} if out_dir.is_dir() else set()
+    for path, content in sorted(expected.items()):
+        if not path.is_file():
+            print(f"Generated agent missing: {rel(path)}", file=sys.stderr)
+            ok = False
+        elif path.read_text(encoding="utf-8") != content:
+            print(f"Generated agent is out of date: {rel(path)}", file=sys.stderr)
+            ok = False
+    for path in sorted(actual - set(expected)):
+        print(f"Generated agent is stale: {rel(path)}", file=sys.stderr)
+        ok = False
+    return ok
+
+
+def _write_copies(out_dir: Path, expected: dict[Path, str]) -> None:
+    """写しを書き、元に無い写しを消す。"""
+    # 古い symlink（`../agents`）を外してから書く。外さずに書くと元の定義を書き換える。
+    if out_dir.is_symlink():
+        out_dir.unlink()
+    out_dir.mkdir(parents=True, exist_ok=True)
+    for path, content in expected.items():
+        path.write_text(content, encoding="utf-8")
+    for path in sorted(set(out_dir.iterdir()) - set(expected)):
+        path.unlink()
+
+
+def main(argv: list[str]) -> int:
+    plugin_dir, check = Path(argv[0]), argv[1] == "true"
+    return 0 if sync(plugin_dir, check) else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))
diff --git a/scripts/tests/agy_build_helpers.py b/scripts/tests/agy_build_helpers.py
index eb290b960..fe6661e70 100644
--- a/scripts/tests/agy_build_helpers.py
+++ b/scripts/tests/agy_build_helpers.py
@@ -17,6 +17,7 @@
 
 REPO_ROOT = Path(__file__).resolve().parents[2]
 BUILD = REPO_ROOT / "scripts/build-runtime-plugins.sh"
+AGY_AGENTS = REPO_ROOT / "scripts/lib/agy_agents.py"
 
 FAMILY = "ndf"
 VERSION = "9.3.0"
@@ -31,6 +32,8 @@ def build_tree(base: Path, skills: list[str] | None = None) -> Path:
 
     (root / "scripts").mkdir(parents=True)
     (root / "scripts/build-runtime-plugins.sh").write_text(BUILD.read_text(encoding="utf-8"), encoding="utf-8")
+    (root / "scripts/lib").mkdir()
+    (root / "scripts/lib/agy_agents.py").write_text(AGY_AGENTS.read_text(encoding="utf-8"), encoding="utf-8")
     # MCP プラグインの同期はディレクトリを走査する。空でも存在していないと読めない。
     (root / "plugins/mcp").mkdir(parents=True)
 
@@ -67,3 +70,13 @@ def output_of(result: subprocess.CompletedProcess[str]) -> str:
 
 def links_dir(root: Path) -> Path:
     return root / f"plugins/{FAMILY}/dev.agy/skills"
+
+
+def agents_dir(root: Path) -> Path:
+    """エージェント定義の正（Claude Code の定義）。"""
+    return root / f"plugins/{FAMILY}/agents"
+
+
+def agy_agents_dir(root: Path) -> Path:
+    """agy に配る定義（生成した写し）。"""
+    return root / f"plugins/{FAMILY}/dev.agy/agents"
diff --git a/scripts/tests/test_agy_agents.py b/scripts/tests/test_agy_agents.py
new file mode 100644
index 000000000..1ae1b7507
--- /dev/null
+++ b/scripts/tests/test_agy_agents.py
@@ -0,0 +1,192 @@
+"""agy に配るエージェント定義の生成（scripts/lib/agy_agents.py。#2087）。
+
+agy 1.4 系は `model` に tier 名（`flash` / `pro` / `inherit`）しか受け付けない。`dev.agy/agents/` には
+`plugins/ndf/agents/` の写しを置き、`model:` の 1 行だけを tier 名へ変える。agy の無い環境で、
+写しの追従し忘れ・手直し・余り・足りなさと、受け付けられない `model` を見つける。
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import os
+import shutil
+from pathlib import Path
+
+from agy_build_helpers import agents_dir, agy_agents_dir, build_tree, output_of, run_build
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+PLUGIN_DIR = REPO_ROOT / "plugins/ndf"
+
+_spec = importlib.util.spec_from_file_location("agy_agents", REPO_ROOT / "scripts/lib/agy_agents.py")
+assert _spec and _spec.loader
+agy_agents = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(agy_agents)
+
+
+def _agent(name: str, model: str | None, body: str = "本文") -> str:
+    model_line = f"model: {model}\n" if model is not None else ""
+    return f"---\nname: {name}\n{model_line}description: |\n  {name} の説明\n---\n\n{body}\n"
+
+
+def _tree(tmp_path: Path, agents: dict[str, str | None]) -> Path:
+    root = build_tree(tmp_path)
+    for name, model in agents.items():
+        (agents_dir(root) / f"{name}.md").write_text(_agent(name, model), encoding="utf-8")
+    return root
+
+
+def _generated(root: Path) -> Path:
+    result = run_build(root)
+    assert result.returncode == 0, output_of(result)
+    return agy_agents_dir(root)
+
+
+def test_repo_copies_use_agy_tiers() -> None:
+    """配る写しの `model` は tier 名か欄なし（受け入れ条件 7・I3）。"""
+    copies = sorted((PLUGIN_DIR / "dev.agy/agents").glob("*.md"))
+    assert copies
+    for path in copies:
+        model = agy_agents.frontmatter_model(path.read_text(encoding="utf-8"))
+        assert model is None or model in agy_agents.AGY_TIERS, f"{path}: {model}"
+
+
+def test_repo_copies_follow_every_definition() -> None:
+    """写しのファイル名の集合は、エージェント定義の集合と等しい（I1）。"""
+    assert not (PLUGIN_DIR / "dev.agy/agents").is_symlink()
+    sources = sorted(p.name for p in (PLUGIN_DIR / "agents").glob("*.md"))
+    copies = sorted(p.name for p in (PLUGIN_DIR / "dev.agy/agents").iterdir())
+    assert copies == sources
+
+
+def test_model_map_values_are_tiers() -> None:
+    """対応表の値はすべて tier 名（I4）。"""
+    assert set(agy_agents.MODEL_MAP.values()) <= agy_agents.AGY_TIERS
+
+
+def test_build_converts_model_and_keeps_the_rest(tmp_path: Path) -> None:
+    """`model:` の 1 行だけが変わり、ほかは元とバイト列で一致する（受け入れ条件 6・7、I2）。"""
+    root = _tree(tmp_path, {"cheap": "sonnet", "strong": "opus", "plain": None})
+    out = _generated(root)
+    for name, tier in (("cheap", "flash"), ("strong", "pro"), ("plain", None)):
+        source = (agents_dir(root) / f"{name}.md").read_text(encoding="utf-8")
+        copy = (out / f"{name}.md").read_text(encoding="utf-8")
+        assert agy_agents.frontmatter_model(copy) == tier
+        assert [line for line in source.splitlines() if not line.startswith("model:")] == [
+            line for line in copy.splitlines() if not line.startswith("model:")
+        ]
+    assert run_build(root, check=True).returncode == 0
+
+
+def test_build_does_not_touch_the_definitions(tmp_path: Path) -> None:
+    """古い symlink のままでも、生成は元の定義を書き換えない。`--check` は symlink を落とす（I6）。"""
+    root = _tree(tmp_path, {"cheap": "sonnet"})
+    before = (agents_dir(root) / "cheap.md").read_bytes()
+    shutil.rmtree(_generated(root))
+    os.symlink("../agents", agy_agents_dir(root))
+
+    result = run_build(root, check=True)
+    assert result.returncode == 1
+    assert "Generated agents must be files, not a symlink" in output_of(result)
+
+    out = _generated(root)
+    assert not out.is_symlink() and out.is_dir()
+    assert (agents_dir(root) / "cheap.md").read_bytes() == before
+    assert run_build(root, check=True).returncode == 0
+
+
+def test_check_detects_missing_copy(tmp_path: Path) -> None:
+    """定義を足して生成し直さないと `--check` が落ち、足りない写しを示す（I1）。"""
+    root = _tree(tmp_path, {"cheap": "sonnet"})
+    _generated(root)
+    (agents_dir(root) / "added.md").write_text(_agent("added", "sonnet"), encoding="utf-8")
+    result = run_build(root, check=True)
+    assert result.returncode == 1
+    assert "Generated agent missing: plugins/ndf/dev.agy/agents/added.md" in output_of(result)
+    assert (_generated(root) / "added.md").is_file()
+
+
+def test_check_detects_stale_copy(tmp_path: Path) -> None:
+    """定義を消して生成し直さないと `--check` が落ち、余った写しを示す。生成し直すと消える（I1）。"""
+    root = _tree(tmp_path, {"cheap": "sonnet", "gone": "opus"})
+    _generated(root)
+    (agents_dir(root) / "gone.md").unlink()
+    result = run_build(root, check=True)
+    assert result.returncode == 1
+    assert "Generated agent is stale: plugins/ndf/dev.agy/agents/gone.md" in output_of(result)
+    assert not (_generated(root) / "gone.md").exists()
+
+
+def test_check_detects_body_drift_and_hand_edits(tmp_path: Path) -> None:
+    """定義の本文を変えて生成し直さない・写しを手で直す、のどちらも `--check` が落ちる（I2）。"""
+    root = _tree(tmp_path, {"cheap": "sonnet"})
+    out = _generated(root)
+    source = agents_dir(root) / "cheap.md"
+    source.write_text(source.read_text(encoding="utf-8").replace("本文", "本文!"), encoding="utf-8")
+    result = run_build(root, check=True)
+    assert result.returncode == 1
+    assert "Generated agent is out of date: plugins/ndf/dev.agy/agents/cheap.md" in output_of(result)
+
+    _generated(root)
+    copy = out / "cheap.md"
+    copy.write_text(copy.read_text(encoding="utf-8").replace("model: flash", "model: sonnet"), encoding="utf-8")
+    assert run_build(root, check=True).returncode == 1
+
+
+def test_unknown_model_stops_build_and_check(tmp_path: Path) -> None:
+    """対応表に無い値は、生成も `--check` も止め、パスと値を示す（I5）。"""
+    root = _tree(tmp_path, {"odd": "claude-opus-5-5"})
+    for check in (False, True):
+        result = run_build(root, check=check)
+        assert result.returncode == 1
+        assert "Unknown model for agy: plugins/ndf/agents/odd.md: claude-opus-5-5" in output_of(result)
+    assert not agy_agents_dir(root).exists()
+
+
+def test_broken_model_map_stops_build(tmp_path: Path) -> None:
+    """対応表の値が tier 名でないと、生成を始めずに止まる（I4）。"""
+    root = _tree(tmp_path, {"cheap": "sonnet"})
+    plugin_dir = root / "plugins/ndf"
+    assert agy_agents.sync(plugin_dir, check=False, model_map={"sonnet": "sonnet"}) is False
+    assert not agy_agents_dir(root).exists()
+
+
+# 現状固定テスト: agy_copy と frontmatter_model は frontmatter の走査を別々に持つ。
+# 走査をまとめても、次の入力での出力が変わらないことを固定する。
+_FRONTMATTER_CASES = [
+    # (入力, frontmatter_model の値, agy_copy の出力)
+    ("", None, ""),
+    ("model: sonnet\n", None, "model: sonnet\n"),
+    ("本文\n---\nmodel: sonnet\n---\n", None, "本文\n---\nmodel: sonnet\n---\n"),
+    ("---\nname: a\n---\n\nmodel: sonnet\n", None, "---\nname: a\n---\n\nmodel: sonnet\n"),
+    ("---\nname: a\n---\n", None, "---\nname: a\n---\n"),
+    ("---\nname: a\nmodel: sonnet\n---\n", "sonnet", "---\nname: a\nmodel: flash\n---\n"),
+    ("---  \nmodel: opus\n  ---\n", "opus", "---  \nmodel: pro\n  ---\n"),
+    ("---\nmodel: 'opus'\n---\n", "opus", "---\nmodel: pro\n---\n"),
+    ('---\nmodel: "haiku"\n---\n', "haiku", "---\nmodel: flash\n---\n"),
+    ("---\nmodel:   inherit   \n---\n", "inherit", "---\nmodel: inherit\n---\n"),
+    ("---\r\nmodel: sonnet\r\n---\r\n", "sonnet", "---\r\nmodel: flash\r\n---\r\n"),
+    ("---\nmodel: sonnet", "sonnet", "---\nmodel: flash"),
+    ("---\nname: a\nmodel: sonnet\n", "sonnet", "---\nname: a\nmodel: flash\n"),
+    ("---\n  model: sonnet\n---\n", None, "---\n  model: sonnet\n---\n"),
+    ("---\nmodel: sonnet\nmodel: opus\n---\n", "sonnet", "---\nmodel: flash\nmodel: opus\n---\n"),
+]
+
+
+def test_characterize_frontmatter_model_and_agy_copy() -> None:
+    """frontmatter の走査の境界（無い・閉じない・欄なし・引用符・CRLF・字下げ・2 つ目の欄）を固定する。"""
+    for text, model, copy in _FRONTMATTER_CASES:
+        assert agy_agents.frontmatter_model(text) == model, repr(text)
+        assert agy_agents.agy_copy(text, agy_agents.MODEL_MAP) == copy, repr(text)
+
+
+def test_characterize_agy_copy_unknown_model() -> None:
+    """対応表に無い値は UnknownModel で止まり、値（引用符を外したもの）を持つ。frontmatter の外の値は見ない。"""
+    for text, value in (("---\nmodel: gpt\n---\n", "gpt"), ("---\nmodel: 'x y'\n---\n", "x y"), ("---\nmodel:\n---\n", "")):
+        try:
+            agy_agents.agy_copy(text, agy_agents.MODEL_MAP)
+        except agy_agents.UnknownModel as exc:
+            assert exc.args == (value,)
+        else:
+            raise AssertionError(repr(text))
+    text = "---\nname: a\n---\nmodel: gpt\n"
+    assert agy_agents.agy_copy(text, agy_agents.MODEL_MAP) == text
diff --git a/scripts/tests/test_agy_distribution.py b/scripts/tests/test_agy_distribution.py
index e1faf292f..d69cfcb04 100644
--- a/scripts/tests/test_agy_distribution.py
+++ b/scripts/tests/test_agy_distribution.py
@@ -85,12 +85,11 @@ def test_dev_agy_links_follow_the_manifest() -> None:
         assert (link / "SKILL.md").is_file()
 
 
-@pytest.mark.parametrize("name,target", [("agents", "../agents"), ("scripts", "../scripts")])
-def test_dev_agy_shares_the_implementation(name: str, target: str) -> None:
-    """エージェント定義と hook の実体は 4 ランタイムで共有する（設計の決定 6）。"""
-    link = PLUGIN_DIR / "dev.agy" / name
+def test_dev_agy_shares_the_implementation() -> None:
+    """hook の実体は 4 ランタイムで共有する（設計の決定 6）。エージェント定義は写しを置く（#2087）。"""
+    link = PLUGIN_DIR / "dev.agy" / "scripts"
     assert link.is_symlink(), f"{link} が symlink でない"
-    assert os.readlink(link) == target
+    assert os.readlink(link) == "../scripts"
 
 
 def test_build_creates_the_links(tmp_path: Path) -> None:
diff --git a/tests/runtime-smoke/fixtures/hooks-positive-control/assert-characterization.sh b/tests/runtime-smoke/fixtures/hooks-positive-control/assert-characterization.sh
index 77264b422..05136066e 100755
--- a/tests/runtime-smoke/fixtures/hooks-positive-control/assert-characterization.sh
+++ b/tests/runtime-smoke/fixtures/hooks-positive-control/assert-characterization.sh
@@ -95,6 +95,195 @@ if actual != expected:
   fi
 }
 
+setup_codex_app_server_stub() {
+  # codex-hooks-list.py の main の分岐を固定する。app-server だけをスタブへ置き換え、
+  # 受け取った要求と作業ディレクトリを CODEX_STUB_RECORD へ書き、シナリオごとに応答を変える。
+  cat >"$base/bin/codex" <<'PY'
+#!/usr/bin/env python3
+import json
+import os
+import sys
+import time
+
+scenario = os.environ["CODEX_STUB_SCENARIO"]
+record = os.environ.get("CODEX_STUB_RECORD")
+received = []
+
+if scenario == "stderr-tail":
+    sys.stderr.write("stub stderr line\n")
+    sys.stderr.flush()
+
+for line in sys.stdin:
+    message = json.loads(line)
+    received.append(message)
+    if message.get("id") != 2:
+        continue
+    if record:
+        with open(record, "w", encoding="utf-8") as f:
+            json.dump({"argv": sys.argv[1:], "cwd": os.getcwd(), "received": received}, f)
+    if scenario == "exit-early":
+        print("partial line before exit", flush=True)
+        sys.exit(0)
+    if scenario == "no-data":
+        print(json.dumps({"id": 2, "result": {"other": 1}}), flush=True)
+    elif scenario == "result-not-dict":
+        print(json.dumps({"id": 2, "result": ["data"]}), flush=True)
+    elif scenario == "stderr-tail":
+        time.sleep(0.5)
+        print(json.dumps({"id": 2, "error": {"message": "fixture error"}}), flush=True)
+    else:
+        result = {"data": [{"pluginId": "日本語@ai-plugins", "hooks": []}], "extra": None}
+        print(json.dumps({"id": 2, "result": result}), flush=True)
+    if scenario == "hang-after-answer":
+        time.sleep(60)
+    break
+PY
+  chmod +x "$base/bin/codex"
+}
+
+run_codex_hooks_list() {
+  # $1: シナリオ、$2: 出力の接頭辞。残りは codex-hooks-list.py への引数。終了コードを hooks_list_rc へ残す。
+  local scenario="$1" prefix="$2"
+  shift 2
+  hooks_list_rc=0
+  CODEX_STUB_SCENARIO="$scenario" CODEX_STUB_RECORD="$base/$prefix.record" PATH="$base/bin:$PATH" \
+    python3 "$REPO_ROOT/tests/runtime-smoke/lib/codex-hooks-list.py" "$@" \
+    >"$base/$prefix.stdout" 2>"$base/$prefix.stderr" || hooks_list_rc=$?
+}
+
+expect_hooks_list_failure() {
+  # $1: 接頭辞、$2: 標準エラーに含まれるべき文言
+  if [ "$hooks_list_rc" -ne 1 ] || ! grep -Fq "$2" "$base/$1.stderr" || [ -s "$base/$1.stdout" ]; then
+    echo "codex-hooks-list did not fail with '$2' (exit $hooks_list_rc)" >&2
+    cat "$base/$1.stderr" >&2
+    exit 1
+  fi
+}
+
+test_codex_hooks_list_no_data() {
+  setup_codex_app_server_stub
+  run_codex_hooks_list no-data no-data --cwd "$base/cwd"
+  expect_hooks_list_failure no-data "hooks/list response has no result.data:"
+  grep -Fq '"other": 1' "$base/no-data.stderr" || { echo "no-data failure did not include the response body" >&2; exit 1; }
+
+  run_codex_hooks_list result-not-dict result-not-dict --cwd "$base/cwd"
+  expect_hooks_list_failure result-not-dict "hooks/list response has no result.data:"
+}
+
+test_codex_hooks_list_exit_early() {
+  setup_codex_app_server_stub
+  run_codex_hooks_list exit-early exit-early --cwd "$base/cwd"
+  expect_hooks_list_failure exit-early "codex app-server exited before answering hooks/list:"
+  grep -Fq "partial line before exit" "$base/exit-early.stderr" \
+    || { echo "exit-early failure did not include the received lines" >&2; exit 1; }
+}
+
+test_codex_hooks_list_stderr_tail() {
+  setup_codex_app_server_stub
+  run_codex_hooks_list stderr-tail stderr-tail --cwd "$base/cwd"
+  expect_hooks_list_failure stderr-tail "hooks/list returned an error:"
+  if ! grep -Fq "app-server stderr (tail):" "$base/stderr-tail.stderr" \
+    || ! grep -Fq "stub stderr line" "$base/stderr-tail.stderr"; then
+    echo "codex-hooks-list did not append the app-server stderr tail" >&2
+    cat "$base/stderr-tail.stderr" >&2
+    exit 1
+  fi
+}
+
+test_codex_hooks_list_requests_and_output() {
+  # 送る要求の並び・作業ディレクトリ・出力の書式（indent=2、非 ASCII をそのまま、末尾の改行）を固定する。
+  setup_codex_app_server_stub
+  run_codex_hooks_list success success --cwd "$base/cwd"
+  if [ "$hooks_list_rc" -ne 0 ]; then
+    echo "codex-hooks-list failed on a plain result (exit $hooks_list_rc)" >&2
+    cat "$base/success.stderr" >&2
+    exit 1
+  fi
+  if ! BASE="$base" python3 - <<'PY'
+import json
+import os
+import sys
+
+base = os.environ["BASE"]
+cwd = os.path.realpath(os.path.join(base, "cwd"))
+record = json.load(open(os.path.join(base, "success.record"), encoding="utf-8"))
+expected_received = [
+    {"id": 1, "method": "initialize", "params": {"clientInfo": {"name": "runtime-smoke", "version": "0.0.0"}}},
+    {"method": "initialized"},
+    {"id": 2, "method": "hooks/list", "params": {"cwds": [os.path.join(base, "cwd")]}},
+]
+errors = []
+if record["argv"] != ["app-server"]:
+    errors.append(f"argv: {record['argv']}")
+if os.path.realpath(record["cwd"]) != cwd:
+    errors.append(f"cwd: {record['cwd']}")
+if record["received"] != expected_received:
+    errors.append(f"received: {record['received']}")
+stdout = open(os.path.join(base, "success.stdout"), encoding="utf-8").read()
+expected_stdout = (
+    "{\n"
+    '  "data": [\n'
+    "    {\n"
+    '      "pluginId": "日本語@ai-plugins",\n'
+    '      "hooks": []\n'
+    "    }\n"
+    "  ],\n"
+    '  "extra": null\n'
+    "}\n"
+)
+if stdout != expected_stdout:
+    errors.append(f"stdout: {stdout!r}")
+if errors:
+    sys.stderr.write("\n".join(errors) + "\n")
+    sys.exit(1)
+PY
+  then
+    echo "codex-hooks-list requests or output changed" >&2
+    exit 1
+  fi
+}
+
+test_codex_hooks_list_default_cwd() {
+  # --cwd を省くと、起動したディレクトリを app-server の作業ディレクトリと cwds に使う。
+  setup_codex_app_server_stub
+  mkdir -p "$base/default-cwd"
+  hooks_list_rc=0
+  (cd "$base/default-cwd" && CODEX_STUB_SCENARIO=success CODEX_STUB_RECORD="$base/default-cwd.record" PATH="$base/bin:$PATH" \
+    python3 "$REPO_ROOT/tests/runtime-smoke/lib/codex-hooks-list.py" \
+    >"$base/default-cwd.stdout" 2>"$base/default-cwd.stderr") || hooks_list_rc=$?
+  if [ "$hooks_list_rc" -ne 0 ] || ! BASE="$base" python3 - <<'PY'
+import json
+import os
+import sys
+
+base = os.environ["BASE"]
+expected = os.path.realpath(os.path.join(base, "default-cwd"))
+record = json.load(open(os.path.join(base, "default-cwd.record"), encoding="utf-8"))
+cwds = record["received"][-1]["params"]["cwds"]
+if os.path.realpath(record["cwd"]) != expected or [os.path.realpath(c) for c in cwds] != [expected]:
+    sys.stderr.write(f"cwd={record['cwd']} cwds={cwds}\n")
+    sys.exit(1)
+PY
+  then
+    echo "codex-hooks-list did not default --cwd to the current directory (exit $hooks_list_rc)" >&2
+    cat "$base/default-cwd.stderr" >&2
+    exit 1
+  fi
+}
+
+test_codex_hooks_list_kills_lingering_server() {
+  # 応答の後も終わらない app-server は止めて、待たずに 0 で返る。
+  setup_codex_app_server_stub
+  local started=$SECONDS
+  run_codex_hooks_list hang-after-answer hang --cwd "$base/cwd"
+  if [ "$hooks_list_rc" -ne 0 ] || [ $((SECONDS - started)) -ge 20 ] \
+    || ! grep -Fq '"pluginId": "日本語@ai-plugins"' "$base/hang.stdout"; then
+    echo "codex-hooks-list did not stop a lingering app-server (exit $hooks_list_rc)" >&2
+    cat "$base/hang.stderr" >&2
+    exit 1
+  fi
+}
+
 test_reject_marketplace_without_hooks() {
   cat >"$base/bin/codex" <<'SH'
 #!/usr/bin/env bash
@@ -279,6 +468,12 @@ mkdir -p "$base/bin" "$base/cwd"
 
 test_codex_hooks_list_error
 test_codex_hooks_list_filter
+test_codex_hooks_list_no_data
+test_codex_hooks_list_exit_early
+test_codex_hooks_list_stderr_tail
+test_codex_hooks_list_requests_and_output
+test_codex_hooks_list_default_cwd
+test_codex_hooks_list_kills_lingering_server
 test_reject_marketplace_without_hooks
 test_claude_missing_hooks
 test_claude_control_silent
diff --git a/tests/runtime-smoke/lib/codex-hooks-list.py b/tests/runtime-smoke/lib/codex-hooks-list.py
index cc32d9a21..95ceef960 100755
--- a/tests/runtime-smoke/lib/codex-hooks-list.py
+++ b/tests/runtime-smoke/lib/codex-hooks-list.py
@@ -30,6 +30,45 @@ def fail(message, stderr_tail):
     sys.exit(1)
 
 
+def parse_hooks_list_response(line):
+    """1 行を JSON として読み、hooks/list への応答なら辞書を返す。それ以外の行は None。"""
+    try:
+        message = json.loads(line)
+    except json.JSONDecodeError:
+        return None
+    if not isinstance(message, dict) or message.get("id") != HOOKS_LIST_ID:
+        return None
+    return message
+
+
+def extract_result(message, received, stderr_tail):
+    body = "".join(received)
+    if "error" in message:
+        fail("hooks/list returned an error:\n" + body, stderr_tail)
+    result = message.get("result")
+    if not isinstance(result, dict) or "data" not in result:
+        fail("hooks/list response has no result.data:\n" + body, stderr_tail)
+    return result
+
+
+def wait_for_hooks_list(lines, reader_done, stderr_tail):
+    """hooks/list への応答を待ち、result を返す。応答前の終了と時間切れは fail で終える。"""
+    deadline = time.monotonic() + TIMEOUT_SECONDS
+    received = []
+    while True:
+        while lines:
+            line = lines.popleft()
+            received.append(line)
+            message = parse_hooks_list_response(line)
+            if message is not None:
+                return extract_result(message, received, stderr_tail)
+        if reader_done.is_set() and not lines:
+            fail("codex app-server exited before answering hooks/list:\n" + "".join(received), stderr_tail)
+        if time.monotonic() > deadline:
+            fail(f"codex app-server did not answer hooks/list within {TIMEOUT_SECONDS}s:\n" + "".join(received), stderr_tail)
+        time.sleep(0.05)
+
+
 def main():
     parser = argparse.ArgumentParser()
     parser.add_argument("--cwd", default=os.getcwd())
@@ -67,32 +106,9 @@ def read_stdout():
         send({"method": "initialized"})
         send({"id": HOOKS_LIST_ID, "method": "hooks/list", "params": {"cwds": [args.cwd]}})
 
-        deadline = time.monotonic() + TIMEOUT_SECONDS
-        received = []
-        while True:
-            while lines:
-                line = lines.popleft()
-                received.append(line)
-                try:
-                    message = json.loads(line)
-                except json.JSONDecodeError:
-                    continue
-                if not isinstance(message, dict) or message.get("id") != HOOKS_LIST_ID:
-                    continue
-                body = "".join(received)
-                if "error" in message:
-                    fail("hooks/list returned an error:\n" + body, stderr_tail)
-                result = message.get("result")
-                if not isinstance(result, dict) or "data" not in result:
-                    fail("hooks/list response has no result.data:\n" + body, stderr_tail)
-                json.dump(result, sys.stdout, ensure_ascii=False, indent=2)
-                sys.stdout.write("\n")
-                return
-            if reader_done.is_set() and not lines:
-                fail("codex app-server exited before answering hooks/list:\n" + "".join(received), stderr_tail)
-            if time.monotonic() > deadline:
-                fail(f"codex app-server did not answer hooks/list within {TIMEOUT_SECONDS}s:\n" + "".join(received), stderr_tail)
-            time.sleep(0.05)
+        result = wait_for_hooks_list(lines, reader_done, stderr_tail)
+        json.dump(result, sys.stdout, ensure_ascii=False, indent=2)
+        sys.stdout.write("\n")
     finally:
         if proc.poll() is None:
             proc.kill()