diff --git a/CLAUDE.md b/CLAUDE.md
index 2698151..f8a888a 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -4,7 +4,7 @@
 
 ## 開発進捗
 
-最新: PLAN_05 フェーズ 1 として層②テストの共通ハーネスを作り，保存失敗が成功扱いになる不具合を赤→緑で修正した
+最新: PLAN_05 フェーズ 2 として層②テストを校正・撮影・切断・UI 連携に広げ，報告台帳の 4 件を赤→緑で修正した
 ※ 本欄は**最新ステップ 1 行のみ上書き更新**．詳細な進捗履歴（動機・設計判断・失敗パターン）は [docs/PROGRESS.md](docs/PROGRESS.md) に追記する．運用ルールは `.claude/rules/progress-log.md` を参照（該当ファイル編集時に自動ロードされる）．
 
 ## 必須ルール（コード実装時）
diff --git a/TIASshot.Tests/CameraBaseCalibrationIntegrationTests.cs b/TIASshot.Tests/CameraBaseCalibrationIntegrationTests.cs
new file mode 100644
index 0000000..a5ca7d3
--- /dev/null
+++ b/TIASshot.Tests/CameraBaseCalibrationIntegrationTests.cs
@@ -0,0 +1,368 @@
+#if SELFTEST
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using NUnit.Framework;
+using OpenCvSharp;
+
+namespace TIASshot.Tests {
+
+    /// <summary>
+    /// CameraBase の自動校正（ProcessCalibrationFrame → DetectChart → 固定判定 → ホワイトバランス → CalcTcc）と，
+    /// 校正後・校正中の切断の結合ロジックテスト（層②）．
+    ///
+    /// 仕様: SPEC_01「自動キャリブレーション」「撮影」「データ保存（キャリブレーション保存ファイル）」・
+    /// testing.md「層②: CameraBase の校正」「CameraBase の切断・終了」
+    ///   - プレビュー中に舌診チャートを検出すると自動でキャリブレーションを開始する
+    ///   - キャリブレーション完了後に撮影ボタンが有効になる
+    ///   - 算出した変換行列等は保存フォルダに保存される
+    ///   - 校正の途中で失敗したときは，再検出できる状態へ戻る
+    ///   - 切断時はチャートマスク（ネイティブ資源）を解放する（CLAUDE.md: Mat は確実に解放する）
+    ///
+    /// 失敗の注入:
+    ///   - チャートの映っていない一様なフレーム（SelfTestChart.CreatePlainFrame）を流す
+    ///   - 校正の収束処理（LogCalibrationConverged）で 1 回だけ例外を投げる派生偽カメラ
+    ///
+    /// 観測は SelfTestCamera のアクセサ（IsCalibrated・PreviewError・ChartMasksSnapshot・CalibrationFolder）・
+    /// Form1.SelfTest.cs のアクセサ（SelfTestShotsEnabled）・保存されたファイルで行う．
+    /// 本クラスは SELFTEST 構成（Debug|x64）でのみコンパイルされる．
+    /// </summary>
+    [TestFixture]
+    public class CameraBaseCalibrationIntegrationTests {
+
+        // 校正のプレビューで流すフレーム数の余裕（ハーネスの Calibrate と同じ考え方）
+        private const int ExtraFrames = 60;
+
+        // 舌診チャートの色票数（SPEC_01: 24 色票）
+        private const int PatchCount = 24;
+
+        // ================================================================================
+        // 校正の状態遷移（正常系）
+        // ================================================================================
+
+        /// <summary>
+        /// 舌診チャートを流すと校正が完了し，撮影ボタンが無効から有効に変わる．
+        /// </summary>
+        [Test, Category("Integration")]
+        public void 校正_チャートを流す_校正完了で撮影ボタンが無効から有効になる() {
+            // Arrange / Act
+            var obs = IntegrationHarness.Run(h => {
+                var camera = h.CreateChartCamera();
+                var enabledBefore = h.Form.SelfTestShotsEnabled;
+                RunPreview(h, camera, MaxCalibrationFrames(), stopWhenCalibrated: true);
+                // CalcTcc → EnableShots は UI スレッドへの Invoke のため，反映をメッセージ処理で待つ
+                h.PumpUntil(() => h.Form.SelfTestShotsEnabled || !camera.IsCalibrated, "撮影ボタン有効化の反映", TimeSpan.FromSeconds(3));
+                return new {
+                    enabledBefore,
+                    camera.IsCalibrated,
+                    PreviewError = camera.PreviewError?.ToString(),
+                    enabledAfter = h.Form.SelfTestShotsEnabled,
+                };
+            });
+
+            // Assert
+            Assert.That(obs.enabledBefore, Is.False, "校正前は撮影ボタンが無効であること");
+            using (Assert.EnterMultipleScope()) {
+                Assert.That(obs.PreviewError, Is.Null, "校正中に例外が出ないこと");
+                Assert.That(obs.IsCalibrated, Is.True, "チャートを流すと校正が完了すること");
+                Assert.That(obs.enabledAfter, Is.True, "校正完了後に撮影ボタンが有効になること");
+            }
+        }
+
+        /// <summary>
+        /// 校正が完了すると，SPEC_01「キャリブレーション保存ファイル」に挙げたファイルが校正の保存フォルダに作られる．
+        /// </summary>
+        [Test, Category("Integration")]
+        public void 校正_チャートを流す_キャリブレーション保存ファイルが保存される() {
+            // Arrange / Act
+            var obs = IntegrationHarness.Run(h => {
+                var camera = h.CreateChartCamera();
+                h.Calibrate(camera);
+                var folder = camera.CalibrationFolder;
+                var channels = GetConversionChannels();
+                var expected = new List<string> {
+                    Config.GetString("File/TccImage"),
+                    Config.GetString("File/TccRoisImage"),
+                    Config.GetString("File/TccRgbValues"),
+                };
+                foreach (var ch in channels) {
+                    expected.Add(WithChannel("File/TccSrgbValues", ch));
+                    expected.Add(WithChannel("File/ConvRgb2Srgb", ch));
+                    expected.Add(WithChannel("File/ConvRgb2Xyz", ch));
+                    expected.Add(WithChannel("File/ConvSrgb2Xyz", ch));
+                }
+                var saved = !string.IsNullOrEmpty(folder) && Directory.Exists(folder)
+                    ? Directory.GetFiles(folder).Select(Path.GetFileName).ToList()
+                    : new List<string>();
+                return new { folder, channels, expected, saved, underRoot = folder != null && IsUnder(folder, h.SaveRoot) };
+            });
+
+            // Assert
+            Assert.That(obs.channels, Is.Not.Empty, "前提: 変換次元が 1 つ以上設定されていること");
+            using (Assert.EnterMultipleScope()) {
+                Assert.That(obs.underRoot, Is.True, $"校正の保存先が一時保存先の配下であること: {obs.folder}");
+                Assert.That(obs.saved, Is.SupersetOf(obs.expected), $"保存されたファイル: [{string.Join(", ", obs.saved)}]");
+            }
+        }
+
+        // ================================================================================
+        // 校正の状態遷移（失敗注入）
+        // ================================================================================
+
+        /// <summary>
+        /// チャートの映っていないフレームだけを流すと，校正は完了せず，撮影ボタンは無効のままである．
+        /// </summary>
+        [Test, Category("Integration")]
+        public void 校正_チャートの映っていないフレーム_校正が完了せず撮影ボタンが無効のまま() {
+            // Arrange / Act
+            var obs = IntegrationHarness.Run(h => {
+                var camera = h.CreateCamera(i => SelfTestChart.CreatePlainFrame(i, SelfTestChart.FrameWidth, SelfTestChart.FrameHeight));
+                RunPreview(h, camera, MaxCalibrationFrames(), stopWhenCalibrated: true);
+                // 誤って有効化の Invoke が積まれていた場合に反映されるよう，少しメッセージを処理してから観測する
+                h.PumpFor(TimeSpan.FromMilliseconds(100));
+                return new {
+                    camera.FramesDelivered,
+                    camera.IsCalibrated,
+                    PreviewError = camera.PreviewError?.ToString(),
+                    Masks = camera.ChartMasksSnapshot.Count,
+                    enabled = h.Form.SelfTestShotsEnabled,
+                };
+            });
+
+            // Assert
+            Assert.That(obs.FramesDelivered, Is.EqualTo(MaxCalibrationFramesForFastConfig()), "前提: 上限までフレームを流したこと");
+            using (Assert.EnterMultipleScope()) {
+                Assert.That(obs.PreviewError, Is.Null, "チャートが無くても例外にならないこと");
+                Assert.That(obs.IsCalibrated, Is.False, "チャートが無ければ校正は完了しないこと");
+                Assert.That(obs.Masks, Is.Zero, "チャートが無ければマスクは作られないこと");
+                Assert.That(obs.enabled, Is.False, "校正が完了していないので撮影ボタンは無効のままであること");
+            }
+        }
+
+        /// <summary>
+        /// 校正の途中（収束処理）で例外が起きた後，再びプレビューを流すとチャートを再検出して校正を完了でき，
+        /// 撮影ボタンが有効になる（途中で失敗したときに再検出できる状態へ戻る）．
+        /// </summary>
+        [Test, Category("Integration")]
+        public void 校正_途中で例外_再びプレビューを流すと再検出して校正が完了する() {
+            // Arrange / Act
+            var obs = IntegrationHarness.Run(h => {
+                var camera = h.Connect(h.Track(new ConvergeFailOnceCamera(h.Form, h.ChartFrameFactory())));
+                RunPreview(h, camera, MaxCalibrationFrames(), stopWhenCalibrated: true);
+                var firstError = camera.PreviewError;
+                var calibratedAfterFailure = camera.IsCalibrated;
+                var enabledAfterFailure = h.Form.SelfTestShotsEnabled;
+
+                RunPreview(h, camera, MaxCalibrationFrames(), stopWhenCalibrated: true);
+                h.PumpUntil(() => h.Form.SelfTestShotsEnabled || !camera.IsCalibrated, "撮影ボタン有効化の反映", TimeSpan.FromSeconds(3));
+                return new {
+                    injectedThrown = ReferenceEquals(firstError, camera.Injected),
+                    firstError = firstError?.ToString(),
+                    calibratedAfterFailure,
+                    enabledAfterFailure,
+                    calibratedAfterRetry = camera.IsCalibrated,
+                    enabledAfterRetry = h.Form.SelfTestShotsEnabled,
+                };
+            });
+
+            // Assert
+            Assert.That(obs.injectedThrown, Is.True, $"前提: 注入した例外で 1 回目の校正が中断されたこと（実際: {obs.firstError ?? "例外なし"}）");
+            using (Assert.EnterMultipleScope()) {
+                Assert.That(obs.calibratedAfterFailure, Is.False, "途中で失敗した校正は完了扱いにならないこと");
+                Assert.That(obs.enabledAfterFailure, Is.False, "途中で失敗した校正では撮影ボタンが有効にならないこと");
+                Assert.That(obs.calibratedAfterRetry, Is.True, "再びプレビューを流すと校正が完了すること");
+                Assert.That(obs.enabledAfterRetry, Is.True, "再校正の完了で撮影ボタンが有効になること");
+            }
+        }
+
+        /// <summary>
+        /// 校正の途中で例外が起きた後にチャートを再検出したとき，失敗した校正で作られた旧チャートマスクは解放される
+        /// （差し替えの際に旧マスクを Dispose せずに捨てるとネイティブメモリがリークする）．
+        /// </summary>
+        [Test, Category("Integration")]
+        public void 校正_途中で例外の後に再検出_旧チャートマスクが全て解放される() {
+            // Arrange / Act
+            var obs = IntegrationHarness.Run(h => {
+                var camera = h.Connect(h.Track(new ConvergeFailOnceCamera(h.Form, h.ChartFrameFactory())));
+                RunPreview(h, camera, MaxCalibrationFrames(), stopWhenCalibrated: true);
+                var firstError = camera.PreviewError;
+                var oldMasks = camera.ChartMasksSnapshot.ToList();
+
+                RunPreview(h, camera, MaxCalibrationFrames(), stopWhenCalibrated: true);
+                var newMasks = camera.ChartMasksSnapshot.ToList();
+                return new {
+                    injectedThrown = ReferenceEquals(firstError, camera.Injected),
+                    oldCount = oldMasks.Count,
+                    oldDisposed = oldMasks.Count(m => m.IsDisposed),
+                    newCount = newMasks.Count,
+                    newDisposed = newMasks.Count(m => m.IsDisposed),
+                    replaced = oldMasks.All(o => !newMasks.Any(n => ReferenceEquals(n, o))),
+                    calibrated = camera.IsCalibrated,
+                };
+            });
+
+            // Assert
+            Assert.That(obs.injectedThrown, Is.True, "前提: 注入した例外で 1 回目の校正が中断されたこと");
+            Assert.That(obs.oldCount, Is.EqualTo(PatchCount), "前提: 1 回目の検出で 24 色票ぶんのマスクが作られたこと");
+            Assert.That(obs.calibrated, Is.True, "前提: 2 回目のプレビューで再検出・校正が完了したこと");
+            using (Assert.EnterMultipleScope()) {
+                Assert.That(obs.replaced, Is.True, "再検出でマスクが新しいものに差し替わること");
+                Assert.That(obs.oldDisposed, Is.EqualTo(obs.oldCount), "差し替えられた旧マスクが全て解放されること");
+                Assert.That(obs.newCount, Is.EqualTo(PatchCount), "新しいマスクが 24 色票ぶんあること");
+                Assert.That(obs.newDisposed, Is.Zero, "使用中の新しいマスクは解放されていないこと");
+            }
+        }
+
+        // ================================================================================
+        // 切断
+        // ================================================================================
+
+        /// <summary>
+        /// 校正完了後に切断すると，チャートマスクが全て解放され，カメラの保持するマスクが空になる．
+        /// </summary>
+        [Test, Category("Integration")]
+        public void 切断_校正完了後_チャートマスクが全て解放され空になる() {
+            // Arrange / Act
+            var obs = IntegrationHarness.Run(h => {
+                var camera = h.CreateChartCamera();
+                h.Calibrate(camera);
+                var masks = camera.ChartMasksSnapshot.ToList();
+                Exception error = null;
+                try {
+                    camera.Disconnect();
+                } catch (Exception ex) {
+                    error = ex;
+                }
+                return new {
+                    count = masks.Count,
+                    disposed = masks.Count(m => m.IsDisposed),
+                    remaining = camera.ChartMasksSnapshot.Count,
+                    error = error?.ToString(),
+                };
+            });
+
+            // Assert
+            Assert.That(obs.count, Is.EqualTo(PatchCount), "前提: 校正で 24 色票ぶんのマスクが作られたこと");
+            using (Assert.EnterMultipleScope()) {
+                Assert.That(obs.error, Is.Null, "切断が例外にならないこと");
+                Assert.That(obs.disposed, Is.EqualTo(obs.count), "切断でマスクが全て解放されること");
+                Assert.That(obs.remaining, Is.Zero, "切断後はマスクを保持しないこと");
+            }
+        }
+
+        /// <summary>
+        /// 校正の途中（チャート検出後・変換行列算出前）にプレビューを止めて切断しても例外にならず，
+        /// チャートマスクが全て解放され，校正完了扱い・撮影ボタン有効化にはならない．
+        /// 校正フレーム数を大きくして，校正中の状態（IsCalibrating）を確実に作ってから切断する．
+        /// </summary>
+        [Test, Category("Integration")]
+        public void 切断_校正中_例外にならずチャートマスクが解放され撮影ボタンは無効のまま() {
+            // Arrange
+            var options = new IntegrationOptions().WithConfig("Calib/Frames", "100000");
+
+            // Act
+            var obs = IntegrationHarness.Run(h => {
+                var camera = h.CreateChartCamera();
+                camera.StartPreview(1000000, 1, false);
+                h.PumpUntil(() => camera.IsCalibrating || !camera.IsPreviewRunning, "チャート検出（校正の開始）", TimeSpan.FromSeconds(5));
+                var calibratingAtStop = camera.IsCalibrating;
+                camera.RequestStopPreview();
+                h.PumpUntil(() => !camera.IsPreviewRunning, "プレビューの停止", TimeSpan.FromSeconds(3));
+                var masks = camera.ChartMasksSnapshot.ToList();
+                Exception error = null;
+                try {
+                    camera.Disconnect();
+                } catch (Exception ex) {
+                    error = ex;
+                }
+                h.PumpFor(TimeSpan.FromMilliseconds(100));
+                return new {
+                    calibratingAtStop,
+                    PreviewError = camera.PreviewError?.ToString(),
+                    count = masks.Count,
+                    disposed = masks.Count(m => m.IsDisposed),
+                    remaining = camera.ChartMasksSnapshot.Count,
+                    error = error?.ToString(),
+                    camera.IsCalibrated,
+                    enabled = h.Form.SelfTestShotsEnabled,
+                };
+            }, options);
+
+            // Assert
+            Assert.That(obs.calibratingAtStop, Is.True, "前提: 校正中（チャート検出後）に停止したこと");
+            Assert.That(obs.count, Is.EqualTo(PatchCount), "前提: 24 色票ぶんのマスクがあること");
+            using (Assert.EnterMultipleScope()) {
+                Assert.That(obs.PreviewError, Is.Null, "校正中に停止してもプレビューで例外が出ないこと");
+                Assert.That(obs.error, Is.Null, "校正中の切断が例外にならないこと");
+                Assert.That(obs.disposed, Is.EqualTo(obs.count), "切断でマスクが全て解放されること");
+                Assert.That(obs.remaining, Is.Zero, "切断後はマスクを保持しないこと");
+                Assert.That(obs.IsCalibrated, Is.False, "校正の途中で切断したら校正完了扱いにならないこと");
+                Assert.That(obs.enabled, Is.False, "校正の途中で切断したら撮影ボタンは無効のままであること");
+            }
+        }
+
+        // ================================================================================
+        // 共通処理
+        // ================================================================================
+
+        /// <summary>プレビューを流し，停止するまでメッセージを処理して待つ（PreviewError は判定しない）</summary>
+        private static void RunPreview(IntegrationHarness h, SelfTestCamera camera, int maxFrames, bool stopWhenCalibrated) {
+            camera.StartPreview(maxFrames, 0, stopWhenCalibrated);
+            h.PumpUntil(() => !camera.IsPreviewRunning, "プレビューの終了");
+        }
+
+        /// <summary>校正に必要なフレーム数＋余裕（一時設定が読み込まれている STA スレッドで呼ぶ）</summary>
+        private static int MaxCalibrationFrames() {
+            return Config.GetInt("Calib/ChartSetCount") + Config.GetInt("Calib/Frames") + ExtraFrames;
+        }
+
+        /// <summary>ハーネスの既定設定（FastConfig）での MaxCalibrationFrames（テストスレッドで期待値に使う）</summary>
+        private static int MaxCalibrationFramesForFastConfig() {
+            return int.Parse(IntegrationHarness.FastConfig["Calib/ChartSetCount"])
+                + int.Parse(IntegrationHarness.FastConfig["Calib/Frames"]) + ExtraFrames;
+        }
+
+        private static string WithChannel(string key, int channel) {
+            return Config.GetString(key).Replace("{CN}", $"{channel:00}");
+        }
+
+        /// <summary>設定の変換次元（Calib/ConversionChannels．SPEC_02: カンマ区切り・4〜17 の範囲のみ有効）</summary>
+        private static List<int> GetConversionChannels() {
+            return Config.GetString("Calib/ConversionChannels")
+                .Split(',')
+                .Select(x => int.Parse(x.Trim()))
+                .Where(x => x >= 4 && x <= 17)
+                .Distinct()
+                .OrderBy(x => x)
+                .ToList();
+        }
+
+        private static bool IsUnder(string path, string root) {
+            var p = Path.GetFullPath(path).TrimEnd('\\') + "\\";
+            var r = Path.GetFullPath(root).TrimEnd('\\') + "\\";
+            return p.StartsWith(r, StringComparison.OrdinalIgnoreCase);
+        }
+
+        /// <summary>
+        /// 校正の収束処理（LogCalibrationConverged．CalcTcc の直前に呼ばれる）で 1 回目だけ例外を投げる偽カメラ（失敗注入用）．
+        /// 例外はプレビュースレッドで捕捉され PreviewError に記録される（プレビューは止まる）．
+        /// </summary>
+        private sealed class ConvergeFailOnceCamera : SelfTestCamera {
+
+            private int _calls;
+
+            public ConvergeFailOnceCamera(Form1 form, Func<int, Mat> frameFactory) : base(form, frameFactory) { }
+
+            /// <summary>注入した例外（PreviewError と同一インスタンスかで注入の成立を確かめる）</summary>
+            public InvalidOperationException Injected { get; } = new InvalidOperationException("注入: 校正の収束処理で失敗");
+
+            protected override void LogCalibrationConverged() {
+                if (Interlocked.Increment(ref _calls) == 1) throw Injected;
+                base.LogCalibrationConverged();
+            }
+        }
+    }
+}
+#endif
diff --git a/TIASshot.Tests/CameraBaseShotIntegrationTests.cs b/TIASshot.Tests/CameraBaseShotIntegrationTests.cs
new file mode 100644
index 0000000..ade0e20
--- /dev/null
+++ b/TIASshot.Tests/CameraBaseShotIntegrationTests.cs
@@ -0,0 +1,505 @@
+#if SELFTEST
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Text.RegularExpressions;
+using NUnit.Framework;
+using OpenCvSharp;
+
+namespace TIASshot.Tests {
+
+    /// <summary>
+    /// CameraBase の撮影ループ（ShotMulti → RunShotLoop → CaptureShots）・保存キューの後始末（ResetShotQueue・DrainShots）・
+    /// 保存中の切断の結合ロジックテスト（層②）．保存失敗の通知は CameraBaseSaveIntegrationTests（フェーズ 1）で扱う．
+    ///
+    /// 仕様: SPEC_01「撮影」「撮影失敗時の挙動」「データ保存（撮影保存ファイル）」・testing.md「層②」
+    ///   - 連続撮影は指定した枚数・間隔で撮影し，`Shot{NO}.png`・`sRGB{CN}_{NO}.jpg`・`Info.csv` を保存する
+    ///   - フレーム取得に失敗した場合，その時点で撮影全体を中止し（残り枚数は撮影しない），中止した旨を通知する．
+    ///     取得済みの画像は保存し，`Info.csv` に中止した旨と理由を記録する．失敗した 1 枚は成功として記録されない
+    ///   - `Info.csv` の撮影ログ部の列は `Shot,Time(ms),Note`．3 列目は中止した行にのみ理由が入る
+    ///     （CSV として 3 列の構造が保たれること．理由にカンマ・改行・引用符が含まれても列・行が崩れない＝RFC 4180）
+    ///   - 撮影ボタンは保存が完了するまで無効のままとなり，保存処理の終了後に再び操作可能になる
+    ///   - 撮影・保存で使った Mat（ネイティブ資源）は残さず解放する（CLAUDE.md・error-handling.md）
+    ///
+    /// 方針未決のためアサートしない: 枚数 0 の完了表示の有無，DrainShots の待機上限，SaveThread の同期 Invoke．
+    ///
+    /// 失敗の注入: CaptureFrame を上書きした派生偽カメラ（<see cref="ProbeCamera"/>）で，指定枚目に
+    /// CaptureFailedException を投げる／撮影開始時に保存先へ同名フォルダを作り画像保存を失敗させる．
+    /// 本クラスは SELFTEST 構成（Debug|x64）でのみコンパイルされる．
+    /// </summary>
+    [TestFixture]
+    public class CameraBaseShotIntegrationTests {
+
+        // 撮影ログのヘッダ（SPEC_01: Shot,Time(ms),Note）
+        private static readonly string[] ShotLogHeader = { "Shot", "Time(ms)", "Note" };
+
+        // 注入する撮影失敗の理由（カンマ・CRLF・ダブルクォートを含む．CSV の列・行を崩しうる文字）
+        private const string TrickyReason = "a,b\r\nc\"d";
+
+        // ================================================================================
+        // 撮影ループ（正常系）
+        // ================================================================================
+
+        /// <summary>
+        /// 連続撮影（3 枚・間隔 0）で，3 枚ぶんの撮影画像・sRGB 変換画像と Info.csv が保存され，
+        /// 撮影ログに 1〜3 枚目の行があり，撮影ボタンが再び有効になる．
+        /// </summary>
+        [Test, Category("Integration")]
+        public void ShotMulti_3枚間隔0_3枚ぶんのファイルと撮影ログが保存され撮影ボタンが再有効化される() {
+            // Arrange / Act
+            var obs = IntegrationHarness.Run(h => {
+                var camera = h.Connect(h.Track(new ProbeCamera(h.Form, h.ChartFrameFactory())));
+                h.Calibrate(camera);
+                h.Form.SelfTestSetMultiShots("3", "0");
+                return ShootMultiAndObserve(h, camera);
+            }, ShotOptions());
+
+            // Assert
+            var expected = new List<string> { obs.InfoName };
+            for (var no = 1; no <= 3; no++) expected.AddRange(obs.ExpectedFilesFor(no));
+            using (Assert.EnterMultipleScope()) {
+                Assert.That(obs.SavedFiles, Is.SupersetOf(expected), $"保存されたファイル: [{string.Join(", ", obs.SavedFiles)}]");
+                Assert.That(obs.ShotLogRows.Select(r => r[0]), Is.EqualTo(new[] { "1", "2", "3" }), "撮影ログに 1〜3 枚目の行があること");
+                Assert.That(obs.Errors, Is.Empty, "エラー通知が無いこと");
+                Assert.That(obs.ShotsEnabled, Is.True, "保存完了後に撮影ボタンが再び有効になること");
+            }
+        }
+
+        /// <summary>
+        /// 連続撮影（2 枚・間隔 150ms）で，撮影ログの 2 枚目の時刻が 1 枚目から間隔以上あとになる
+        /// （SPEC_01: 指定した間隔で連続撮影する）．
+        /// </summary>
+        [Test, Category("Integration")]
+        public void ShotMulti_2枚間隔150ms_撮影ログの時刻が間隔以上離れる() {
+            // Arrange / Act
+            var obs = IntegrationHarness.Run(h => {
+                var camera = h.Connect(h.Track(new ProbeCamera(h.Form, h.ChartFrameFactory())));
+                h.Calibrate(camera);
+                h.Form.SelfTestSetMultiShots("2", "150");
+                return ShootMultiAndObserve(h, camera);
+            }, ShotOptions());
+
+            // Assert
+            Assert.That(obs.ShotLogRows.Count, Is.EqualTo(2), "前提: 撮影ログが 2 行あること");
+            var t1 = long.Parse(obs.ShotLogRows[0][1]);
+            var t2 = long.Parse(obs.ShotLogRows[1][1]);
+            Assert.That(t2 - t1, Is.GreaterThanOrEqualTo(150), $"2 枚目は 1 枚目から 150ms 以上あとに撮影されること（1 枚目 {t1}ms，2 枚目 {t2}ms）");
+        }
+
+        /// <summary>
+        /// 連続撮影の枚数が 0 のとき，例外にならず，撮影ボタンが再び有効になる
+        /// （枚数 0 の完了表示の有無は仕様未決のためアサートしない）．
+        /// </summary>
+        [Test, Category("Integration")]
+        public void ShotMulti_枚数0_例外にならず撮影ボタンが再有効化される() {
+            // Arrange / Act
+            var obs = IntegrationHarness.Run(h => {
+                var camera = h.Connect(h.Track(new ProbeCamera(h.Form, h.ChartFrameFactory())));
+                h.Calibrate(camera);
+                h.Form.SelfTestSetMultiShots("0", "0");
+                return ShootMultiAndObserve(h, camera);
+            }, ShotOptions());
+
+            // Assert
+            using (Assert.EnterMultipleScope()) {
+                Assert.That(obs.ShotError, Is.Null, "枚数 0 の撮影が例外にならないこと");
+                Assert.That(obs.ShotsEnabled, Is.True, "枚数 0 の撮影の後も撮影ボタンが再び有効になること");
+            }
+        }
+
+        // ================================================================================
+        // 撮影ループ（失敗注入: フレーム取得の失敗）
+        // ================================================================================
+
+        /// <summary>
+        /// 連続撮影（3 枚）の 2 枚目でフレーム取得に失敗したとき，撮影を中止して 3 枚目は撮影せず，
+        /// 取得済みの 1 枚目だけが保存され，中止が理由つきで通知され，撮影ボタンが再び有効になる．
+        /// </summary>
+        [Test, Category("Integration")]
+        public void ShotMulti_2枚目のフレーム取得失敗_中止して取得済みのみ保存し理由を通知し撮影ボタンを再有効化する() {
+            // Arrange / Act
+            var obs = IntegrationHarness.Run(h => {
+                var camera = h.Connect(h.Track(new ProbeCamera(h.Form, h.ChartFrameFactory()) { FailCaptureAt = 2, FailMessage = "注入: フレーム取得失敗" }));
+                h.Calibrate(camera);
+                h.Form.SelfTestSetMultiShots("3", "0");
+                return ShootMultiAndObserve(h, camera);
+            }, ShotOptions());
+
+            // Assert
+            using (Assert.EnterMultipleScope()) {
+                Assert.That(obs.ShotError, Is.Null, "フレーム取得の失敗は撮影の例外として呼び出し元へ漏れないこと（中止として扱う）");
+                Assert.That(obs.CaptureCalls, Is.EqualTo(2), "失敗した 2 枚目で中止し，3 枚目は撮影しないこと");
+                Assert.That(obs.SavedFiles, Is.SupersetOf(obs.ExpectedFilesFor(1)), "取得済みの 1 枚目は保存されること");
+                Assert.That(obs.SavedFiles, Has.No.Member(obs.RgbFileFor(2)), "失敗した 2 枚目は保存されないこと");
+                Assert.That(obs.SavedFiles, Has.No.Member(obs.RgbFileFor(3)), "中止後の 3 枚目は保存されないこと");
+                Assert.That(obs.Errors, Has.Some.Matches<string>(e => e != null && e.Contains("注入: フレーム取得失敗")),
+                    $"中止した旨が理由つきで通知されること．通知: [{string.Join(" / ", obs.Errors)}]");
+                Assert.That(obs.ShotsEnabled, Is.True, "中止後も撮影ボタンが再び有効になること");
+            }
+        }
+
+        /// <summary>
+        /// フレーム取得失敗の理由にカンマ・改行・ダブルクォートが含まれても，Info.csv の撮影ログは CSV（RFC 4180）として
+        /// Shot,Time(ms),Note の 3 列構造を保ち，中止行の Note は理由を含む 1 つのフィールドになる．失敗した枚は成功行として記録されない．
+        /// </summary>
+        [Test, Category("Integration")]
+        public void ShotMulti_理由にカンマ改行引用符を含むフレーム取得失敗_InfoCsvの中止行がNoteを含む3列になる() {
+            // Arrange / Act
+            var obs = IntegrationHarness.Run(h => {
+                var camera = h.Connect(h.Track(new ProbeCamera(h.Form, h.ChartFrameFactory()) { FailCaptureAt = 2, FailMessage = TrickyReason }));
+                h.Calibrate(camera);
+                h.Form.SelfTestSetMultiShots("3", "0");
+                return ShootMultiAndObserve(h, camera);
+            }, ShotOptions());
+
+            // Assert
+            Assert.That(obs.InfoText, Is.Not.Null, "前提: Info.csv が保存されていること");
+            Assert.That(obs.ShotLogHeaderFound, Is.True, "前提: 撮影ログのヘッダ（Shot,Time(ms),Note）が 1 つの行として解釈できること");
+            var rows = obs.ShotLogRows;
+            Assert.That(rows.Count, Is.EqualTo(2),
+                $"撮影ログは 1 枚目（成功）と 2 枚目（中止）の 2 行であること．解釈結果: [{string.Join(" | ", rows.Select(r => string.Join(" ¦ ", r)))}]");
+            using (Assert.EnterMultipleScope()) {
+                Assert.That(rows[0].Count, Is.EqualTo(2), "成功した 1 枚目の行は Shot,Time の 2 フィールドであること");
+                Assert.That(rows[0][0], Is.EqualTo("1"));
+                Assert.That(rows[0][1], Does.Match(@"^\d+$"), "1 枚目の Time は整数（ms）であること");
+                Assert.That(obs.RawShotLines, Has.Some.Matches<string>(l => Regex.IsMatch(l, @"^1,\d+$")), "カンマを含まない 1 枚目の行は従来どおり 1,<time> の形であること");
+                Assert.That(rows[1].Count, Is.EqualTo(3), "中止した 2 枚目の行は Shot,Time,Note の 3 フィールドであること");
+                Assert.That(rows[1][0], Is.EqualTo("2"));
+                Assert.That(rows[1][1], Does.Match(@"^\d+$"), "2 枚目の Time は整数（ms）であること");
+                Assert.That(rows[1].Count > 2 ? rows[1][2] : "", Does.Contain(TrickyReason), "Note に元の理由がそのまま 1 フィールドとして入ること");
+            }
+        }
+
+        // ================================================================================
+        // 保存キューの後始末（SaveThread 例外時・ResetShotQueue）
+        // ================================================================================
+
+        /// <summary>
+        /// 保存キューを作り直す（ResetShotQueue）とき，前のキューに残っていた Mat は解放される
+        /// （BlockingCollection の破棄だけでは中身の Mat はリークする）．
+        /// </summary>
+        [Test, Category("Integration")]
+        public void ResetShotQueue_前のキューにMatが残っている_残っていたMatが全て解放される() {
+            // Arrange / Act
+            var obs = IntegrationHarness.Run(h => {
+                var camera = h.Connect(h.Track(new ProbeCamera(h.Form, h.ChartFrameFactory())));
+                var left1 = new Mat(4, 4, MatType.CV_8UC3, Scalar.All(1));
+                var left2 = new Mat(4, 4, MatType.CV_8UC3, Scalar.All(2));
+                try {
+                    camera.AddToShotQueue(left1);
+                    camera.AddToShotQueue(left2);
+                    camera.ResetQueue();
+                    return new { d1 = left1.IsDisposed, d2 = left2.IsDisposed };
+                } finally {
+                    // 解放されていなかった場合（不具合時）の後始末
+                    left1.Dispose();
+                    left2.Dispose();
+                }
+            });
+
+            // Assert
+            using (Assert.EnterMultipleScope()) {
+                Assert.That(obs.d1, Is.True, "残っていた 1 つ目の Mat が解放されること");
+                Assert.That(obs.d2, Is.True, "残っていた 2 つ目の Mat が解放されること");
+            }
+        }
+
+        /// <summary>
+        /// 連続撮影（3 枚）で 1 枚目の画像保存に失敗したとき（保存スレッドが例外で保存ループを抜ける），
+        /// 撮影した全てのフレーム（保存されなかった 2・3 枚目を含む）が解放され，撮影ボタンが再び有効になる．
+        /// </summary>
+        [Test, Category("Integration")]
+        public void ShotMulti_1枚目の保存失敗_撮影した全フレームが解放され撮影ボタンが再有効化される() {
+            // Arrange / Act
+            var obs = IntegrationHarness.Run(h => {
+                var camera = h.Connect(h.Track(new ProbeCamera(h.Form, h.ChartFrameFactory()) { BlockSaveNo = 1 }));
+                h.Calibrate(camera);
+                h.Form.SelfTestSetMultiShots("3", "0");
+                var o = ShootMultiAndObserve(h, camera);
+                o.CapturedDisposed = camera.Captured.Count(m => m.IsDisposed);
+                return o;
+            }, ShotOptions());
+
+            // Assert
+            Assert.That(obs.Errors, Is.Not.Empty, "前提: 保存失敗が通知されたこと（失敗注入が効いたこと）");
+            Assert.That(obs.CaptureCalls, Is.EqualTo(3), "前提: 3 枚とも撮影されたこと");
+            using (Assert.EnterMultipleScope()) {
+                Assert.That(obs.CapturedDisposed, Is.EqualTo(obs.CaptureCalls), "撮影した全フレームが解放されること（保存されなかったフレームを含む）");
+                Assert.That(obs.ShotsEnabled, Is.True, "保存失敗後も撮影ボタンが再び有効になること");
+            }
+        }
+
+        // ================================================================================
+        // 切断（保存中）
+        // ================================================================================
+
+        /// <summary>
+        /// 連続撮影の直後（保存スレッドの動作中）に切断しても例外にならず，保存は最後まで行われ，
+        /// 撮影ボタンが再び有効になり，チャートマスクが解放される．
+        /// 保存スレッドは UI スレッドへの Invoke（進捗表示）を伴うため，UI スレッドがメッセージを処理するまでは
+        /// 必ず生存している．撮影直後にメッセージを処理せずに切断することで「保存中の切断」を決定的に作る．
+        /// </summary>
+        [Test, Category("Integration")]
+        public void 切断_保存中_例外にならず保存が完了し撮影ボタンが再有効化されマスクが解放される() {
+            // Arrange / Act
+            var obs = IntegrationHarness.Run(h => {
+                var camera = h.Connect(h.Track(new ProbeCamera(h.Form, h.ChartFrameFactory())));
+                h.Calibrate(camera);
+                h.Form.SelfTestSetMultiShots("3", "0");
+                var masks = camera.ChartMasksSnapshot.ToList();
+                h.Form.SelfTestClearLog();
+                h.Form.EnableShots(false);
+
+                camera.ShotMulti();
+                var savingAtDisconnect = camera.IsSaveThreadStarted;
+                string disconnectError = null;
+                try {
+                    camera.Disconnect();
+                } catch (Exception ex) {
+                    disconnectError = ex.ToString();
+                }
+                h.WaitSaveFinished(camera);
+
+                var o = Observe(h, camera, null);
+                o.SavingAtDisconnect = savingAtDisconnect;
+                o.DisconnectError = disconnectError;
+                o.MaskCount = masks.Count;
+                o.MasksDisposed = masks.Count(m => m.IsDisposed);
+                o.PreviewRunning = camera.IsPreviewRunning;
+                return o;
+            }, ShotOptions());
+
+            // Assert
+            Assert.That(obs.SavingAtDisconnect, Is.True, "前提: 保存スレッドの動作中に切断したこと");
+            var expected = new List<string>();
+            for (var no = 1; no <= 3; no++) expected.AddRange(obs.ExpectedFilesFor(no));
+            using (Assert.EnterMultipleScope()) {
+                Assert.That(obs.DisconnectError, Is.Null, "保存中の切断が例外にならないこと");
+                Assert.That(obs.Errors, Is.Empty, $"保存中に切断しても保存は失敗しないこと．通知: [{string.Join(" / ", obs.Errors)}]");
+                Assert.That(obs.SavedFiles, Is.SupersetOf(expected), "撮影済みの 3 枚は保存されること");
+                Assert.That(obs.ShotsEnabled, Is.True, "保存完了後に撮影ボタンが再び有効になること");
+                Assert.That(obs.MasksDisposed, Is.EqualTo(obs.MaskCount), "切断でチャートマスクが全て解放されること");
+                Assert.That(obs.PreviewRunning, Is.False, "切断後にプレビューが動いていないこと");
+            }
+        }
+
+        // ================================================================================
+        // 共通処理
+        // ================================================================================
+
+        /// <summary>
+        /// 撮影系テストの実行条件．保存時間の大半は変換次元ごとの sRGB 変換のため，変換次元を 1 つ（4）に絞って
+        /// 層②全体の実行時間の目安（30 秒）に収める．全次元での保存はフェーズ 1 の CameraBaseSaveIntegrationTests が確認する．
+        /// </summary>
+        private static IntegrationOptions ShotOptions() {
+            return new IntegrationOptions().WithConfig("Calib/ConversionChannels", "4");
+        }
+
+        /// <summary>
+        /// 撮影ボタン押下（Form1.ExecuteShot）と同じく撮影ボタンを無効化してから連続撮影し，保存スレッドの終了を待って観測値を集める．
+        /// </summary>
+        private static ShotObservation ShootMultiAndObserve(IntegrationHarness h, ProbeCamera camera) {
+            h.Form.SelfTestClearLog();
+            h.Form.EnableShots(false);
+            string shotError = null;
+            try {
+                camera.ShotMulti();
+            } catch (Exception ex) {
+                shotError = ex.ToString();
+            }
+            h.WaitSaveFinished(camera);
+            return Observe(h, camera, shotError);
+        }
+
+        private static ShotObservation Observe(IntegrationHarness h, ProbeCamera camera, string shotError) {
+            var folder = camera.CurrentSaveFolder;
+            var obs = new ShotObservation {
+                ShotError = shotError,
+                Errors = h.Form.SelfTestErrors.ToList(),
+                Messages = h.Form.SelfTestMessages.ToList(),
+                ShotsEnabled = h.Form.SelfTestShotsEnabled,
+                CaptureCalls = camera.CaptureCalls,
+                InfoName = Config.GetString("File/Info"),
+                RgbPattern = Config.GetString("File/RgbImage"),
+                SrgbPattern = Config.GetString("File/SrgbImage"),
+                Channels = GetConversionChannels(),
+            };
+            if (!string.IsNullOrEmpty(folder) && Directory.Exists(folder)) {
+                obs.SavedFiles = Directory.GetFiles(folder).Select(Path.GetFileName).ToList();
+                var info = Path.Combine(folder, obs.InfoName);
+                if (File.Exists(info)) {
+                    obs.InfoText = File.ReadAllText(info);
+                    ParseShotLog(obs);
+                }
+            }
+            return obs;
+        }
+
+        /// <summary>Info.csv を RFC 4180 として解釈し，撮影ログのヘッダ以降のレコードと生の行を取り出す</summary>
+        private static void ParseShotLog(ShotObservation obs) {
+            var records = ParseCsv(obs.InfoText);
+            var headerIndex = records.FindIndex(r => r.SequenceEqual(ShotLogHeader));
+            obs.ShotLogHeaderFound = headerIndex >= 0;
+            if (headerIndex >= 0) {
+                obs.ShotLogRows = records.Skip(headerIndex + 1).Where(r => !(r.Count == 1 && r[0] == "")).ToList();
+            }
+            var lines = obs.InfoText.Split(new[] { "\r\n" }, StringSplitOptions.None).ToList();
+            var headerLine = lines.IndexOf(string.Join(",", ShotLogHeader));
+            if (headerLine >= 0) obs.RawShotLines = lines.Skip(headerLine + 1).ToList();
+        }
+
+        /// <summary>
+        /// RFC 4180 の CSV を解釈する（テスト用の最小実装）．
+        /// フィールド先頭の " から次の単独の " までを 1 フィールドとし（"" は " 1 文字），その中のカンマ・改行は区切りにしない．
+        /// 引用符で始まらないフィールド内の " は文字として扱う．レコード区切りは CRLF または LF．
+        /// </summary>
+        internal static List<List<string>> ParseCsv(string text) {
+            var records = new List<List<string>>();
+            var record = new List<string>();
+            var field = new StringBuilder();
+            var inQuotes = false;
+            var fieldQuoted = false;
+            var i = 0;
+            Action endField = () => {
+                record.Add(field.ToString());
+                field.Clear();
+                fieldQuoted = false;
+            };
+            Action endRecord = () => {
+                endField();
+                records.Add(record);
+                record = new List<string>();
+            };
+            while (i < text.Length) {
+                var c = text[i];
+                if (inQuotes) {
+                    if (c == '"') {
+                        if (i + 1 < text.Length && text[i + 1] == '"') {
+                            field.Append('"');
+                            i += 2;
+                            continue;
+                        }
+                        inQuotes = false;
+                    } else {
+                        field.Append(c);
+                    }
+                    i++;
+                    continue;
+                }
+                if (c == '"' && field.Length == 0 && !fieldQuoted) {
+                    inQuotes = true;
+                    fieldQuoted = true;
+                } else if (c == ',') {
+                    endField();
+                } else if (c == '\r' && i + 1 < text.Length && text[i + 1] == '\n') {
+                    endRecord();
+                    i++;
+                } else if (c == '\n') {
+                    endRecord();
+                } else {
+                    field.Append(c);
+                }
+                i++;
+            }
+            if (field.Length > 0 || record.Count > 0 || fieldQuoted) endRecord();
+            return records;
+        }
+
+        /// <summary>設定の変換次元（Calib/ConversionChannels．SPEC_02: カンマ区切り・4〜17 の範囲のみ有効）</summary>
+        private static List<int> GetConversionChannels() {
+            return Config.GetString("Calib/ConversionChannels")
+                .Split(',')
+                .Select(x => int.Parse(x.Trim()))
+                .Where(x => x >= 4 && x <= 17)
+                .Distinct()
+                .OrderBy(x => x)
+                .ToList();
+        }
+
+        /// <summary>STA スレッドで集めた観測値（テストスレッドで検証する）</summary>
+        private sealed class ShotObservation {
+            public string ShotError;
+            public List<string> Errors = new List<string>();
+            public List<string> Messages = new List<string>();
+            public bool ShotsEnabled;
+            public int CaptureCalls;
+            public int CapturedDisposed;
+            public string InfoName;
+            public string RgbPattern;
+            public string SrgbPattern;
+            public List<int> Channels = new List<int>();
+            public List<string> SavedFiles = new List<string>();
+            public string InfoText;
+            public bool ShotLogHeaderFound;
+            public List<List<string>> ShotLogRows = new List<List<string>>();
+            public List<string> RawShotLines = new List<string>();
+            public bool SavingAtDisconnect;
+            public string DisconnectError;
+            public int MaskCount;
+            public int MasksDisposed;
+            public bool PreviewRunning;
+
+            /// <summary>SPEC_01 のファイル名規則（{NO}: 連番 4 桁）での撮影画像名</summary>
+            public string RgbFileFor(int no) => RgbPattern.Replace("{NO}", $"{no:0000}");
+
+            /// <summary>連番 no の撮影画像と sRGB 変換画像（全次元）のファイル名（{CN}: 変換次元 2 桁）</summary>
+            public List<string> ExpectedFilesFor(int no) {
+                var list = new List<string> { RgbFileFor(no) };
+                list.AddRange(Channels.Select(ch => SrgbPattern.Replace("{CN}", $"{ch:00}").Replace("{NO}", $"{no:0000}")));
+                return list;
+            }
+        }
+
+        /// <summary>
+        /// 撮影の観測と失敗注入のための偽カメラ．
+        ///   - CaptureFrame の呼び出し回数と返した Mat を記録する（解放の確認用．所有権は従来どおり CameraBase 側）
+        ///   - FailCaptureAt 枚目の CaptureFrame で CaptureFailedException(FailMessage) を投げる
+        ///   - BlockSaveNo 番の撮影画像の保存先に同名フォルダを作り，保存を失敗させる（CameraBaseSaveIntegrationTests と同じ手段）
+        ///   - 保存キューへの直接追加と ResetShotQueue の呼び出し口（ResetShotQueue の後始末の確認用）
+        /// </summary>
+        private sealed class ProbeCamera : SelfTestCamera {
+
+            public ProbeCamera(Form1 form, Func<int, Mat> frameFactory) : base(form, frameFactory) { }
+
+            /// <summary>CaptureFrame で失敗させる枚目（1 始まり．0 なら失敗させない）</summary>
+            public int FailCaptureAt { get; set; }
+
+            /// <summary>失敗させるときの例外メッセージ</summary>
+            public string FailMessage { get; set; } = "注入: フレーム取得失敗";
+
+            /// <summary>保存を失敗させる撮影画像の連番（1 始まり．0 なら失敗させない）</summary>
+            public int BlockSaveNo { get; set; }
+
+            /// <summary>CaptureFrame の呼び出し回数（失敗した回を含む）</summary>
+            public int CaptureCalls { get; private set; }
+
+            /// <summary>CaptureFrame が返した Mat（古い順）</summary>
+            public List<Mat> Captured { get; } = new List<Mat>();
+
+            public void AddToShotQueue(Mat mat) => _shots.Add(mat);
+
+            public void ResetQueue() => ResetShotQueue();
+
+            protected override void BeginShot() {
+                base.BeginShot();
+                if (BlockSaveNo > 0) {
+                    var name = Config.GetString("File/RgbImage").Replace("{NO}", $"{BlockSaveNo:0000}");
+                    Directory.CreateDirectory(Path.Combine(CurrentSaveFolder, name));
+                }
+            }
+
+            protected override Mat CaptureFrame() {
+                CaptureCalls++;
+                if (FailCaptureAt > 0 && CaptureCalls == FailCaptureAt) {
+                    throw new CaptureFailedException(FailMessage);
+                }
+                var frame = base.CaptureFrame();
+                Captured.Add(frame);
+                return frame;
+            }
+        }
+    }
+}
+#endif
diff --git a/TIASshot.Tests/Form1UiIntegrationTests.cs b/TIASshot.Tests/Form1UiIntegrationTests.cs
new file mode 100644
index 0000000..cdae8e4
--- /dev/null
+++ b/TIASshot.Tests/Form1UiIntegrationTests.cs
@@ -0,0 +1,174 @@
+#if SELFTEST
+using System;
+using System.Threading.Tasks;
+using NUnit.Framework;
+
+namespace TIASshot.Tests {
+
+    /// <summary>
+    /// Form1 の UI 連携メソッドを UI スレッド外（ワーカースレッド）から呼んだときの結合ロジックテスト（層②）．
+    ///
+    /// 仕様: testing.md「層②: UI/Form1 の UI 連携メソッド」（UI スレッド外から呼んだときのマーシャリング）・
+    /// SPEC_01「撮影」「データ保存」（データ名は保存フォルダ名 `[時刻]-[データ名]` の一部，連続撮影の枚数・間隔は UI で変更可能）．
+    ///   - 取得系（GetDataName・GetNumMultiShots・GetMultiShotsInterval）は，どのスレッドから呼んでも UI の入力値を返す
+    ///   - 通知系（ShowMessage・EnableShots）は，どのスレッドから呼んでも UI に反映される
+    ///
+    /// ワーカースレッドの呼び出しは Task.Run で行い，UI スレッド（ハーネスの STA スレッド）はメッセージを処理しながら
+    /// 完了を待つ（Control.Invoke は UI スレッドがメッセージを処理しないと返らないため）．
+    /// 観測値は STA スレッド上で集めてテストスレッドへ返し，アサーションはテストスレッドで行う．
+    /// 本クラスは SELFTEST 構成（Debug|x64）でのみコンパイルされる．
+    /// </summary>
+    [TestFixture]
+    public class Form1UiIntegrationTests {
+
+        // ワーカースレッドの呼び出し 1 回に許す時間（Invoke が UI スレッドで処理されるまで）
+        private static readonly TimeSpan WorkerTimeout = TimeSpan.FromSeconds(5);
+
+        // ================================================================================
+        // 取得系（正常系）
+        // ================================================================================
+
+        /// <summary>
+        /// ワーカースレッドから GetDataName を呼んだとき，UI に入力されたデータ名が返る（null にならない）．
+        /// 撮影（ShotOne / ShotMulti）は保存フォルダ名にデータ名を使うため，null だと保存先が誤る．
+        /// </summary>
+        [Test, Category("Integration")]
+        public void GetDataName_ワーカースレッドから呼ぶ_UIに入力したデータ名を返す() {
+            // Arrange / Act
+            var result = IntegrationHarness.Run(h => {
+                h.Form.SelfTestSetDataName("abc");
+                return CallFromWorker(h, () => h.Form.GetDataName());
+            });
+
+            // Assert
+            Assert.That(result.Error, Is.Null, $"ワーカースレッドからの呼び出しが例外にならないこと: {result.Error}");
+            Assert.That(result.Value, Is.EqualTo("abc"));
+        }
+
+        /// <summary>ワーカースレッドから GetNumMultiShots を呼んだとき，UI に入力した枚数が返る</summary>
+        [Test, Category("Integration")]
+        public void GetNumMultiShots_ワーカースレッドから呼ぶ_UIに入力した枚数を返す() {
+            // Arrange / Act
+            var result = IntegrationHarness.Run(h => {
+                h.Form.SelfTestSetMultiShots("7", "250");
+                return CallFromWorker(h, () => h.Form.GetNumMultiShots());
+            });
+
+            // Assert
+            Assert.That(result.Error, Is.Null, $"ワーカースレッドからの呼び出しが例外にならないこと: {result.Error}");
+            Assert.That(result.Value, Is.EqualTo(7));
+        }
+
+        /// <summary>ワーカースレッドから GetMultiShotsInterval を呼んだとき，UI に入力した間隔が返る</summary>
+        [Test, Category("Integration")]
+        public void GetMultiShotsInterval_ワーカースレッドから呼ぶ_UIに入力した間隔を返す() {
+            // Arrange / Act
+            var result = IntegrationHarness.Run(h => {
+                h.Form.SelfTestSetMultiShots("7", "250");
+                return CallFromWorker(h, () => h.Form.GetMultiShotsInterval());
+            });
+
+            // Assert
+            Assert.That(result.Error, Is.Null, $"ワーカースレッドからの呼び出しが例外にならないこと: {result.Error}");
+            Assert.That(result.Value, Is.EqualTo(250));
+        }
+
+        // ================================================================================
+        // 取得系（失敗注入: 数値として解釈できない入力）
+        // ================================================================================
+
+        /// <summary>
+        /// 枚数・間隔の入力欄に数値でない文字列があるとき，ワーカースレッドから呼んでも例外にならず，
+        /// UI スレッドから呼んだ場合と同じ値を返す（既定値そのものは仕様に定めがないためアサートしない）．
+        /// </summary>
+        [Test, Category("Integration")]
+        public void GetNumMultiShotsとGetMultiShotsInterval_数値でない入力をワーカースレッドから読む_UIスレッドと同じ値を返す() {
+            // Arrange / Act
+            var obs = IntegrationHarness.Run(h => {
+                h.Form.SelfTestSetMultiShots("abc", "");
+                return new {
+                    UiNum = h.Form.GetNumMultiShots(),
+                    UiInterval = h.Form.GetMultiShotsInterval(),
+                    WorkerNum = CallFromWorker(h, () => h.Form.GetNumMultiShots()),
+                    WorkerInterval = CallFromWorker(h, () => h.Form.GetMultiShotsInterval()),
+                };
+            });
+
+            // Assert
+            using (Assert.EnterMultipleScope()) {
+                Assert.That(obs.WorkerNum.Error, Is.Null, $"枚数: ワーカースレッドからの呼び出しが例外にならないこと: {obs.WorkerNum.Error}");
+                Assert.That(obs.WorkerInterval.Error, Is.Null, $"間隔: ワーカースレッドからの呼び出しが例外にならないこと: {obs.WorkerInterval.Error}");
+                Assert.That(obs.WorkerNum.Value, Is.EqualTo(obs.UiNum), "枚数: UI スレッドから読んだ値と同じであること");
+                Assert.That(obs.WorkerInterval.Value, Is.EqualTo(obs.UiInterval), "間隔: UI スレッドから読んだ値と同じであること");
+            }
+        }
+
+        // ================================================================================
+        // 通知系
+        // ================================================================================
+
+        /// <summary>ワーカースレッドから ShowMessage を呼んだとき，ステータス表示に反映される</summary>
+        [Test, Category("Integration")]
+        public void ShowMessage_ワーカースレッドから呼ぶ_ステータス表示に反映される() {
+            // Arrange / Act
+            var obs = IntegrationHarness.Run(h => {
+                var call = CallFromWorker(h, () => { h.Form.ShowMessage("worker-message"); return 0; });
+                return new { call.Error, Message = h.Form.SelfTestMessage };
+            });
+
+            // Assert
+            Assert.That(obs.Error, Is.Null, $"ワーカースレッドからの呼び出しが例外にならないこと: {obs.Error}");
+            Assert.That(obs.Message, Is.EqualTo("worker-message"));
+        }
+
+        /// <summary>
+        /// ワーカースレッドから EnableShots(true) / EnableShots(false) を呼んだとき，撮影ボタンの有効・無効に反映される
+        /// （SaveThread が保存完了後に撮影ボタンを再有効化する経路）．
+        /// </summary>
+        [Test, Category("Integration")]
+        public void EnableShots_ワーカースレッドから呼ぶ_撮影ボタンの有効無効に反映される() {
+            // Arrange / Act
+            var obs = IntegrationHarness.Run(h => {
+                var before = h.Form.SelfTestShotsEnabled;
+                var enable = CallFromWorker(h, () => { h.Form.EnableShots(true); return 0; });
+                var afterEnable = h.Form.SelfTestShotsEnabled;
+                var disable = CallFromWorker(h, () => { h.Form.EnableShots(false); return 0; });
+                var afterDisable = h.Form.SelfTestShotsEnabled;
+                return new { before, enable, afterEnable, disable, afterDisable };
+            });
+
+            // Assert
+            Assert.That(obs.before, Is.False, "前提: 開始時（校正前）は撮影ボタンが無効であること");
+            using (Assert.EnterMultipleScope()) {
+                Assert.That(obs.enable.Error, Is.Null, $"有効化の呼び出しが例外にならないこと: {obs.enable.Error}");
+                Assert.That(obs.disable.Error, Is.Null, $"無効化の呼び出しが例外にならないこと: {obs.disable.Error}");
+                Assert.That(obs.afterEnable, Is.True, "EnableShots(true) で撮影ボタンが有効になること");
+                Assert.That(obs.afterDisable, Is.False, "EnableShots(false) で撮影ボタンが無効になること");
+            }
+        }
+
+        // ================================================================================
+        // 共通処理
+        // ================================================================================
+
+        /// <summary>
+        /// 関数をワーカースレッド（Task.Run）で実行し，UI スレッドのメッセージを処理しながら完了を待つ．
+        /// 例外は戻り値の Error に入れて返す（テストスレッドでアサートするため）．
+        /// </summary>
+        private static WorkerResult<T> CallFromWorker<T>(IntegrationHarness h, Func<T> func) {
+            var task = Task.Run(func);
+            h.PumpUntil(() => task.IsCompleted, "ワーカースレッドからの呼び出しの完了", WorkerTimeout);
+            if (task.IsFaulted) {
+                var ex = task.Exception?.GetBaseException();
+                return new WorkerResult<T> { Error = $"{ex?.GetType().Name}: {ex?.Message}" };
+            }
+            return new WorkerResult<T> { Value = task.Result };
+        }
+
+        private sealed class WorkerResult<T> {
+            public T Value;
+            public string Error;
+        }
+    }
+}
+#endif
diff --git a/TIASshot.Tests/TIASshot.Tests.csproj b/TIASshot.Tests/TIASshot.Tests.csproj
index 261d935..db1ef44 100644
--- a/TIASshot.Tests/TIASshot.Tests.csproj
+++ b/TIASshot.Tests/TIASshot.Tests.csproj
@@ -88,6 +88,9 @@
   <ItemGroup>
     <Compile Include="BitmapUtilTests.cs" />
     <Compile Include="CameraBaseSaveIntegrationTests.cs" />
+    <Compile Include="CameraBaseCalibrationIntegrationTests.cs" />
+    <Compile Include="CameraBaseShotIntegrationTests.cs" />
+    <Compile Include="Form1UiIntegrationTests.cs" />
     <Compile Include="GainCalcCalcGainValueTests.cs" />
     <Compile Include="GainCalcTests.cs" />
     <Compile Include="ImageStatsTests.cs" />
diff --git a/TIASshot/Cameras/CameraBase.cs b/TIASshot/Cameras/CameraBase.cs
index a44c352..62a08a7 100644
--- a/TIASshot/Cameras/CameraBase.cs
+++ b/TIASshot/Cameras/CameraBase.cs
@@ -463,11 +463,18 @@
         /// 新しいインスタンスを作成してから古い BlockingCollection を破棄する
         /// （順序を逆にすると，破棄と生成の間に例外が発生した場合に _shots が破棄済みインスタンスを
         ///   指したままとなり，後段の CompleteAdding が ObjectDisposedException になる）．
+        /// BlockingCollection の Dispose は中身の Mat を解放しないため，破棄の前に残っている Mat を
+        /// 取り出して解放する（DrainShots が待機の上限で打ち切った場合等の取り残し対策）．
+        /// 前回の SaveThread は WaitPreviousSaveThread で終了済みのため，ここで取り出しても競合しない．
         /// </summary>
         protected void ResetShotQueue() {
             var previousShots = _shots;
             _shots = new BlockingCollection<Mat>();
-            previousShots?.Dispose();
+            if (previousShots == null) return;
+            while (previousShots.TryTake(out var remaining)) {
+                remaining?.Dispose();
+            }
+            previousShots.Dispose();
         }
 
         /// <summary>
@@ -598,7 +605,8 @@
                 } catch (CaptureFailedException ex) {
                     // 破損データを正常画像として保存しないよう，この枚数以降は撮影しない．
                     Debug.WriteLine($"撮影中止（{i + 1}/{numImages} 枚目）: {ex.Message}");
-                    csv.WriteLine($"{i + 1},{shotTime},撮影失敗のため中止（{ex.Message}）");
+                    // 例外メッセージのカンマ・改行で列や行が崩れないよう，Note 欄は RFC 4180 でエスケープする
+                    csv.WriteLine($"{i + 1},{shotTime},{IoUtil.EscapeCsvField($"撮影失敗のため中止（{ex.Message}）")}");
                     return ex.Message;
                 }
                 csv.WriteLine($"{i + 1},{shotTime}");
@@ -619,7 +627,8 @@
             var masks = _chartDetector.DetectChart(img);
             if (masks == null) return;
 
-            _chartMasks.Clear();
+            // 旧マスク（校正の途中で失敗して再検出する場合等）を解放してから差し替える
+            ReleaseChartMasks();
             _chartMasks.AddRange(masks);
             _calibrating = Config.GetInt("Calib/Frames");
 #if MEMMONITOR
@@ -628,6 +637,18 @@
         }
 
         /// <summary>
+        /// チャートマスク（_chartMasks の各 Mat）を解放して空にする．
+        /// _chartMasks はカメラのコールバックスレッド（ProcessCalibrationFrame）だけが読むため，
+        /// 切断時（Disconnect）はストリーム停止の後に呼ぶこと（コールバックが動いている間に解放しない）．
+        /// </summary>
+        protected void ReleaseChartMasks() {
+            foreach (var mask in _chartMasks) {
+                mask?.Dispose();
+            }
+            _chartMasks.Clear();
+        }
+
+        /// <summary>
         /// ファイル名にチャネル数を追加する
         /// </summary>
         /// <param name="config"></param>
diff --git a/TIASshot/Cameras/IScam.cs b/TIASshot/Cameras/IScam.cs
index 5470817..3718187 100644
--- a/TIASshot/Cameras/IScam.cs
+++ b/TIASshot/Cameras/IScam.cs
@@ -95,6 +95,8 @@
         /// </summary>
         public override void Disconnect() {
             _ic.LiveStop();
+            // コールバック（ProcessCalibrationFrame）が止まった後にチャートマスクを解放する
+            ReleaseChartMasks();
         }
 
         /// <summary>
diff --git a/TIASshot/Cameras/Lucam.cs b/TIASshot/Cameras/Lucam.cs
index f425ace..2f4dcf3 100644
--- a/TIASshot/Cameras/Lucam.cs
+++ b/TIASshot/Cameras/Lucam.cs
@@ -329,6 +329,8 @@
                 }
                 api.CameraClose(_hCam);
                 _hCam = IntPtr.Zero;
+                // カメラを閉じてコールバック（ProcessCalibrationFrame）が止まった後にチャートマスクを解放する
+                ReleaseChartMasks();
                 Debug.WriteLine("カメラ切断");
             }
         }
diff --git a/TIASshot/SelfTest/SelfTestCamera.cs b/TIASshot/SelfTest/SelfTestCamera.cs
index 0098e76..062b302 100644
--- a/TIASshot/SelfTest/SelfTestCamera.cs
+++ b/TIASshot/SelfTest/SelfTestCamera.cs
@@ -61,6 +61,14 @@
         /// <summary>プレビュースレッドが動作中か</summary>
         public bool IsPreviewRunning => _previewThread != null && _previewThread.IsAlive;
 
+        /// <summary>
+        /// 現在のチャートマスク（_chartMasks）の参照のコピー（古い順．検出前・切断後は空）．
+        /// 再検出・切断でマスクが解放された（Mat.IsDisposed）ことを確かめるために使う．
+        /// _chartMasks はプレビュースレッドが書き換えるため，プレビュー停止中（IsPreviewRunning が false）に読むこと．
+        /// 返した Mat の所有権は本クラスに残る（呼び出し側で Dispose しない）．
+        /// </summary>
+        public IReadOnlyList<Mat> ChartMasksSnapshot => _chartMasks.ToArray();
+
         public override bool Connect() {
             if (!BootCheck()) return false;
             DeviceName = "SelfTestCamera";
@@ -81,8 +89,7 @@
                 _bmps[i]?.Dispose();
                 _bmps[i] = null;
             }
-            foreach (var mask in _chartMasks) mask.Dispose();
-            _chartMasks.Clear();
+            ReleaseChartMasks();
             _isPreview = false;
         }
 
diff --git a/TIASshot/UI/Form1.cs b/TIASshot/UI/Form1.cs
index b717f2b..ba043a2 100644
--- a/TIASshot/UI/Form1.cs
+++ b/TIASshot/UI/Form1.cs
@@ -309,7 +309,7 @@
         /// <returns></returns>
         public string GetDataName() {
             if (InvokeRequired) {
-                return (string)Invoke((MethodInvoker)delegate { GetDataName(); });
+                return (string)Invoke(new Func<string>(GetDataName));
             }
             return txtDataName.Text;
         }
@@ -320,7 +320,7 @@
         /// <returns></returns>
         public int GetNumMultiShots() {
             if (InvokeRequired) {
-                return (int)Invoke((MethodInvoker)delegate { GetNumMultiShots(); });
+                return (int)Invoke(new Func<int>(GetNumMultiShots));
             }
             if (int.TryParse(txtNumMultiShots.Text, out int result)) return result;
             return 1;
@@ -332,7 +332,7 @@
         /// <returns></returns>
         public int GetMultiShotsInterval() {
             if (InvokeRequired) {
-                return (int)Invoke((MethodInvoker)delegate { GetMultiShotsInterval(); });
+                return (int)Invoke(new Func<int>(GetMultiShotsInterval));
             }
             if (int.TryParse(txtMultiShotsInterval.Text, out int result)) return result;
             return 1000;
diff --git a/TIASshot/Utils/IoUtil.cs b/TIASshot/Utils/IoUtil.cs
index a731ece..77e3748 100644
--- a/TIASshot/Utils/IoUtil.cs
+++ b/TIASshot/Utils/IoUtil.cs
@@ -148,10 +148,11 @@
         /// CSV の 1 フィールドを RFC 4180 に従ってエスケープする．
         /// カンマ・ダブルクォート・CR・LF を含む場合のみ全体をダブルクォートで囲み，
         /// 内部のダブルクォートを二重化する．それ以外はそのまま返す（null は空文字）．
+        /// WriteInfo のほか，撮影ログ（CameraBase.CaptureShots の Note 欄）でも使う．
         /// </summary>
         /// <param name="field">フィールド値（null 可）</param>
         /// <returns>エスケープ済みのフィールド</returns>
-        private static string EscapeCsvField(string field) {
+        internal static string EscapeCsvField(string field) {
             if (string.IsNullOrEmpty(field)) return "";
             if (field.IndexOfAny(new[] { ',', '"', '\r', '\n' }) < 0) return field;
             return "\"" + field.Replace("\"", "\"\"") + "\"";
diff --git "a/docs/03_PLAN/PLAN_05_\343\203\206\343\202\271\343\203\210\347\266\262\347\276\205\346\200\247\345\220\221\344\270\212\350\250\210\347\224\273.md" "b/docs/03_PLAN/PLAN_05_\343\203\206\343\202\271\343\203\210\347\266\262\347\276\205\346\200\247\345\220\221\344\270\212\350\250\210\347\224\273.md"
index e181f4b..ce7226a 100644
--- "a/docs/03_PLAN/PLAN_05_\343\203\206\343\202\271\343\203\210\347\266\262\347\276\205\346\200\247\345\220\221\344\270\212\350\250\210\347\224\273.md"
+++ "b/docs/03_PLAN/PLAN_05_\343\203\206\343\202\271\343\203\210\347\266\262\347\276\205\346\200\247\345\220\221\344\270\212\350\250\210\347\224\273.md"
@@ -88,6 +88,12 @@
   - `Form1` の UI 連携メソッド（UI スレッド外からの呼び出しを含む）
 - `/auto-audit` 報告台帳のうち，層②で再現テストを書けるようになった項目をここで修正する
 - 完了条件: 上記の各観点に正常系と失敗注入のテストがそろい，層②全体の実行時間が 30 秒の目安に収まる
+- **状態: 完了（2026-10-06）**
+  - 層②のテストは 3 ファイル 21 件を追加し計 24 件．3 回連続で緑，全体で約 19 秒
+  - 報告台帳から 4 件を修正した: `Form1` の取得系メソッドが UI スレッド外で値を返さない，再検出時と切断時にチャートマスクを解放しない，`ResetShotQueue` が残った画像を解放しない，撮影失敗行の Note 欄のクォート漏れ．再現テスト 7 件は修正前のコードで赤になることを確認した
+  - 撮影系のテストは変換次元を 1 つ（`Calib/ConversionChannels=4`）に絞って時間を抑えた．全次元での保存はフェーズ 1 の単発撮影テストで確認している
+  - 方針未決のため観点から外したもの: `CalcTcc` の例外境界と校正画像の保存失敗，`Form1_FormClosing`，`SaveThread` の同期 Invoke，`DrainShots` の待ち時間，撮影枚数 0 の完了表示．束 B（フェーズ 3 と同時）で方針を決めてから扱う
+  - 実機でしか確かめられない残り: 実カメラの `Disconnect` でストリーム停止の直後にマスクを解放してよいか（SDK がコールバックの終了を待つか）
 
 ### フェーズ 3: 層③の切り出し
 
diff --git "a/docs/06_TEST/TEST_01_\343\203\206\343\202\271\343\203\210\344\273\225\346\247\230.md" "b/docs/06_TEST/TEST_01_\343\203\206\343\202\271\343\203\210\344\273\225\346\247\230.md"
index 402c489..9123db6 100644
--- "a/docs/06_TEST/TEST_01_\343\203\206\343\202\271\343\203\210\344\273\225\346\247\230.md"
+++ "b/docs/06_TEST/TEST_01_\343\203\206\343\202\271\343\203\210\344\273\225\346\247\230.md"
@@ -29,6 +29,11 @@
 | `CameraBaseSaveIntegrationTests`（単発・保存成功） | 撮影画像・sRGB 変換画像・Info.csv が保存され，「全ての画像保存完了」が表示され，撮影ボタンが再び有効になる |
 | `CameraBaseSaveIntegrationTests`（単発・撮影画像の保存失敗） | 保存失敗が通知され，「全ての画像保存完了」が表示されず，撮影ボタンが再び有効になる |
 | `CameraBaseSaveIntegrationTests`（連続 3 枚・2 枚目の保存失敗） | 同上 |
+| `CameraBaseCalibrationIntegrationTests`（校正） | 校正完了で撮影ボタンが無効から有効になり，校正保存ファイル（SPEC_01）が作られる．チャートが映らないと完了せずボタンは無効のまま．途中で例外が起きても再検出して完了し，旧チャートマスクは解放される |
+| `CameraBaseCalibrationIntegrationTests`（切断） | 校正後・校正中の切断で例外にならず，チャートマスクが解放される |
+| `CameraBaseShotIntegrationTests`（撮影ループ） | 連続撮影で枚数分のファイルと撮影ログ（間隔どおりの時刻）．枚数 0 で例外にならずボタンが戻る．フレーム取得の失敗で中止・通知され，Info.csv の中止行は理由にカンマ・改行・引用符を含んでも 3 列に収まる |
+| `CameraBaseShotIntegrationTests`（保存キュー・切断） | 保存失敗時に撮影した全フレームが解放される．前回のキューに残った画像が解放される．保存中の切断で例外にならず保存が完了する |
+| `Form1UiIntegrationTests` | データ名・連続撮影の枚数・間隔をワーカースレッドから読んでも UI の入力どおりの値が返る（数値でない入力を含む）．ShowMessage・EnableShots が UI に反映される |
 
 - **合格条件**: 全件緑．新しいケースを追加したときは，取り込む前に 3 回連続で緑になることを確認する
 
diff --git a/docs/PROGRESS.md b/docs/PROGRESS.md
index 1934604..08a9baf 100644
--- a/docs/PROGRESS.md
+++ b/docs/PROGRESS.md
@@ -178,3 +178,7 @@
   - 設計判断: 一時 config の作成と DoEvents による待機はセルフテストのランナーから切り出し，ハーネスと共用した（2 か所で同じ待機処理を持たない）．失敗の注入は，偽カメラの派生で保存先と同名のフォルダを作って `ImWrite` に false を返させる方法にした．保存フォルダ自体を消す案は Info.csv の作成も失敗させて別の経路に乗り，SaveThread との競合で結果も不安定になるため採らなかった．
   - 失敗パターン: 修正を一時的に戻して赤を確認したあと，ファイルを書き戻すときに更新日時が古いまま残り，MSBuild が再コンパイルせず全体テストが誤って赤になった．ファイルを戻したら更新日時も更新するか，クリーンビルドしてから判定する．
   - 後段: `CalcTcc` の校正画像の保存失敗（仕様判断待ち）．tester・refactorer がビルドとテストを自分で実行できない問題は，テストランナー（`run_tests.py`）の追加で解消した（PR #55）．
+
+- [x] **PLAN_05 フェーズ 2: 層②テストの拡充と報告台帳 4 件の修正** (2026-10-06): 校正の状態遷移・撮影ループ・保存キューの後始末・切断・`Form1` の UI 連携に，正常系と失敗注入の結合テストを広げた．あわせて，ハーネスで再現テストを書けるようになった報告台帳の 4 件（UI スレッド外の取得系メソッド，チャートマスクの解放漏れ，保存キューの取り残し，撮影失敗行のクォート漏れ）を，修正前に赤になることを確かめたうえで直した．
+  - 設計判断: 保存中の切断は，`SaveThread` が完了表示を UI スレッドへ Invoke するまで終われない性質を使い，メッセージを処理する前に切断することでタイミングに依存せず再現した．撮影系は変換次元を 1 つに絞り，層②全体を 30 秒の目安に収めた（全次元だと約 28 秒）．
+  - 後段: 方針未決の挙動（`CalcTcc` の例外境界，終了処理，`SaveThread` の同期 Invoke，`DrainShots` の待ち時間）はフェーズ 3（束 B）で方針を決めてから扱う．テスト側に変換次元の取得処理など小さな重複が 3 ファイルに残っている．