Add 3-seed device-contract stress validation

MANIFEST.json

@@ -1,11 +1,11 @@
-{
-    "schema":  "aiflow-hf-research-snapshot-v5",
-    "generated_at":  "2026-07-23T19:28:12.6463736Z",
+{
+    "schema":  "aiflow-hf-research-snapshot-v6",
+    "generated_at":  "2026-07-23T19:35:13.8098972Z",
     "track":  "R_noncommercial_plus_P_proxy",
     "product_validation":  false,
     "public_release":  true,
     "contains_raw_dataset":  false,
-    "tests":  "275 passed",
+    "tests":  "276 passed",
     "files":  [
                   {
                       "path":  "artifacts/boundary_behavior_guard.joblib",
@@ -24,8 +24,8 @@
                   },
                   {
                       "path":  "MODEL_INDEX.json",
-                      "bytes":  2147,
-                      "sha256":  "cb74e4ab8eba8ab5447490bd3e27196f26193ef3cb7d0ed7f8e2dcc95518e53e"
+                      "bytes":  2496,
+                      "sha256":  "b787ca6e82f893c28c5f828587352afdc9de444e515a80578df7891c49cd9444"
                   },
                   {
                       "path":  "models/auxiliary/boundary_auxiliary_head.pt",
@@ -104,8 +104,8 @@
                   },
                   {
                       "path":  "README.md",
-                      "bytes":  10653,
-                      "sha256":  "1e8deaba7b3719cd70782a1c7731cf3c48aeef5791a94ad6eaf985780488c324"
+                      "bytes":  11718,
+                      "sha256":  "2ba69db6d4d51c09c23d33cbc6ccf5dee087a3eadb02192e36002e5ac28162fa"
                   },
                   {
                       "path":  "reports/behavior_role_3seed_summary.json",
@@ -172,6 +172,11 @@
                       "bytes":  16685,
                       "sha256":  "9d250e5c75d4f104971551c07a702810bf94fb5b6e5e587035a624933766356e"
                   },
+                  {
+                      "path":  "reports/p_boundary_device_stress_3seed.json",
+                      "bytes":  10805,
+                      "sha256":  "31d1fd522fce274cedba00cfcc748b7479898a0509b403120d825a26a83fa6f2"
+                  },
                   {
                       "path":  "reports/p_boundary_joint_3seed_summary.json",
                       "bytes":  2645,
@@ -194,8 +199,8 @@
                   },
                   {
                       "path":  "reports/RESEARCH_REPORT.md",
-                      "bytes":  26960,
-                      "sha256":  "c7f9e0a3dc41ed2cf5100aadb3ebd48227e986acfb3f5aa6ec3a8793364a175e"
+                      "bytes":  28194,
+                      "sha256":  "3f128ea412f68061afe013154b783a16585db5c62302eadc486c6872852a7e29"
                   },
                   {
                       "path":  "scripts/audit_math_ink_06_local_baseline_overmerge.py",
@@ -207,6 +212,11 @@
                       "bytes":  11671,
                       "sha256":  "58c175a95cdeb9fc764fb96594a76888122b8f118f2f26da1283e743b1a7cd04"
                   },
+                  {
+                      "path":  "scripts/evaluate_math_ink_06_p_boundary_device_stress.py",
+                      "bytes":  9597,
+                      "sha256":  "249006dd3d8462a1247288066534f8108828c622aeba2834489961ea10ca68f1"
+                  },
                   {
                       "path":  "scripts/summarize_math_ink_06_p_boundary_joint.py",
                       "bytes":  4196,
@@ -258,4 +268,4 @@
                       "sha256":  "160c2dd8db3dd4da77bdd21209a898b73fb0cb5a1b24e59d2c8bc54e159ea3e0"
                   }
               ]
-}
+}

MODEL_INDEX.json

@@ -58,6 +58,18 @@
     "training_track": "P_with_obligations",
     "product_validation": false
   },
+  "device_contract_stress": {
+    "report": "reports/p_boundary_device_stress_3seed.json",
+    "modes": [
+      "coordinate_jitter",
+      "timestamp_missing",
+      "sparse_sampling_recanonicalized",
+      "affine_device"
+    ],
+    "all_seed_mode_gates_passed": true,
+    "android_hardware_validation": false,
+    "product_validation": false
+  },
   "release_state": {
     "track": "R_noncommercial_only",
     "product_validation": false,

README.md

@@ -205,6 +205,19 @@ Same-row, superscript, subscript, fraction slots, wide infix sides의 다섯 bou
 
 Delta checkpoint는 해당 seed의 `base_378.pt`와 `online_adapter.pt` 위에만 적용한다. Seed 간 delta를 교차 적용하면 안 된다.
 
+### 입력 계약 device stress
+
+채택한 세 delta에 좌표 jitter, timestamp 결측, sparse raw-event 재정규화, affine device 변형을 적용했다. Sparse 평가는 canonical point를 임의 삭제하지 않고 시작·끝·pen-up anchor를 보존한 raw event를 6Hz timeline으로 다시 보간한다.
+
+| stress mode | 최악 exact 변화 | 최악 family 변화 |
+|---|---:|---:|
+| coordinate jitter | -0.37%p | -0.37%p |
+| timestamp missing | -0.26%p | -0.32%p |
+| sparse sampling + recanonicalization | -0.48%p | -0.74%p |
+| affine device | -1.53%p | -1.48%p |
+
+세 seed의 모든 mode가 proxy gate를 통과했고 stressed single/cross-boundary recall 최저치는 96.67%였다. 이는 입력 정규화 계약의 강건성 검사이며 실제 Android 기기의 latency, digitizer, touch-driver 검증은 아니다.
+
 ## 출력 범위
 
 의도한 모바일 API:
@@ -231,6 +244,7 @@ SymbolResult:
 - boundary/behavior head는 CROHME R-track 학습물이므로 제품 weight로 distill할 수 없다.
 - P boundary auxiliary head는 합성 배치 proxy이며 validation에서 선택한 threshold 0.70을 사용한다. 실제 수식 검증 전까지 기본 추론에서는 비활성이다.
 - Joint delta도 분리된 고립기호의 수식 배치 proxy로 학습됐으며 실제 사용자의 연속 stroke rhythm을 아직 검증하지 않았다.
+- Device stress는 software perturbation 결과이며 실제 stylus/device-disjoint 성능 근거가 아니다.
 - Android LiteRT 변환, PyTorch/LiteRT logit parity, 저가·중급·고급 기기 benchmark가 남아 있다.
 
 ## 데이터와 권리
@@ -255,4 +269,5 @@ PyTorch checkpoint와 joblib/pickle은 신뢰할 수 없는 출처에서 로드
 - boundary 학습 결과: [`reports/boundary_behavior_guard_report.json`](reports/boundary_behavior_guard_report.json)
 - 3-seed 행동 head: [`reports/behavior_role_3seed_summary.json`](reports/behavior_role_3seed_summary.json)
 - P boundary joint 3-seed: [`reports/p_boundary_joint_3seed_summary.json`](reports/p_boundary_joint_3seed_summary.json)
+- P boundary device stress: [`reports/p_boundary_device_stress_3seed.json`](reports/p_boundary_device_stress_3seed.json)
 - 파일 checksum: [`MANIFEST.json`](MANIFEST.json)

reports/RESEARCH_REPORT.md

@@ -362,6 +362,14 @@ Authentic 4,800개에는 exact CE·family CE·single-symbol boundary loss를 주
 
 세 seed 모두 validation과 paired test gate를 개별 통과했고 exact/family도 모든 seed에서 개선돼 P formula-layout proxy delta로 채택한다. 이는 R-track head를 distill한 결과가 아니라 승인 P trajectory와 알려진 합성 boundary만 사용한 결과다. 다만 분리된 고립기호를 배치한 proxy이므로 실제 사용자의 연속식 stroke rhythm·co-articulation·device sampling 변동은 포함하지 않는다. 제품 검증은 false이며 다음 필수 gate는 실제 P 연속식 writer/device-disjoint boundary 평가다.
 
+### 3-seed device contract stress
+
+채택 delta를 별도 학습 없이 좌표 jitter, timestamp/speed 전체 결측, raw event 절반 희소화 후 6Hz 재보간, x 1.12/y 0.88 affine 조건에서 평가했다. 최초 sparse 실험은 canonical tensor를 직접 절반 삭제해 입력 계약을 위반했으므로 폐기했고, start/end·pen-up anchor를 보존한 재보간 경로로 다시 고정했다.
+
+모든 seed·stress가 clean 대비 exact/family -3%p 이내, single/boundary recall 90% 이상 gate를 통과했다. 최악 exact 하락은 seed-47 affine `-1.53%p`, 최악 family 하락은 seed-31 affine `-1.48%p`였다. Stress 전체의 single-symbol/cross-boundary recall 최저는 각각 96.67%다. Timestamp 결측과 2배 희소 sampling은 최악 exact 하락이 각각 -0.26%p와 -0.48%p 이내였다.
+
+이는 canonical 입력 계약의 변형 내성 증거이지 실제 Android digitizer·WDDM·battery/latency 검증이 아니다. 다음 실제 gate는 raw MotionEvent를 가진 P writer/device-disjoint 연속식이다. 전체 Python 회귀는 276개가 통과했다.
+
 ## 산출물
 
 - `src/math_grid_drawer/research/behavior_context06.py`
@@ -383,6 +391,7 @@ Authentic 4,800개에는 exact CE·family CE·single-symbol boundary loss를 주
 - `scripts/train_math_ink_06_p_boundary_auxiliary.py`
 - `scripts/train_math_ink_06_p_boundary_joint.py`
 - `scripts/summarize_math_ink_06_p_boundary_joint.py`
+- `scripts/evaluate_math_ink_06_p_boundary_device_stress.py`
 - `scripts/analyze_crohme_lattice_failures.py`
 - `tests/test_behavior_context06.py`
 - `tests/test_behavior_role_head06.py`
@@ -408,3 +417,4 @@ Authentic 4,800개에는 exact CE·family CE·single-symbol boundary loss를 주
 - `research/runs/math_ink_06_p_boundary_auxiliary_smoke_20260724/report.json`
 - `research/runs/math_ink_06_p_boundary_auxiliary_fullsmoke_20260724/report.json`
 - `research/runs/math_ink_06_p_boundary_joint_3seed_20260724/run_summary.json`
+- `research/runs/math_ink_06_p_boundary_device_stress_3seed_20260724/report.json`

reports/p_boundary_device_stress_3seed.json

@@ -0,0 +1,335 @@
+{
+  "experiment": "P-MATH-INK-06-BOUNDARY-DEVICE-STRESS-001",
+  "generated_at": "2026-07-23T19:31:55.957852+00:00",
+  "device": "cuda",
+  "cuda_device": "NVIDIA GeForce GTX 1650",
+  "test_cache_key": "26bee2f320c6f0a7eca3c6ca1c9c71dd0cbe89cfaee8d8c415af74ae84c0d879",
+  "stress_contract": {
+    "modes": [
+      "clean",
+      "coordinate_jitter",
+      "timestamp_missing",
+      "sparse_sampling",
+      "affine_device"
+    ],
+    "maximum_exact_regression_pp": 3.0,
+    "maximum_family_regression_pp": 3.0,
+    "minimum_single_symbol_recall": 0.9,
+    "minimum_cross_boundary_recall": 0.9
+  },
+  "seeds": [
+    {
+      "seed": 17,
+      "threshold": 0.525,
+      "modes": {
+        "clean": {
+          "authentic": {
+            "samples": 3782,
+            "exact_top1": 0.7765732416710736,
+            "family_top1": 0.8622421998942359
+          },
+          "boundary": {
+            "threshold": 0.525,
+            "accuracy": 0.9783333333333334,
+            "f1": 0.9785655399835119,
+            "roc_auc": 0.9964729166666666,
+            "single_symbol_recall": 0.9675,
+            "cross_boundary_recall": 0.9891666666666666
+          }
+        },
+        "coordinate_jitter": {
+          "authentic": {
+            "samples": 3782,
+            "exact_top1": 0.775251189846642,
+            "family_top1": 0.8622421998942359
+          },
+          "boundary": {
+            "threshold": 0.525,
+            "accuracy": 0.9783333333333334,
+            "f1": 0.9785831960461285,
+            "roc_auc": 0.9964930555555556,
+            "single_symbol_recall": 0.9666666666666667,
+            "cross_boundary_recall": 0.99
+          },
+          "deltas": {
+            "exact_top1_pp": -0.13220518244315693,
+            "family_top1_pp": 0.0
+          },
+          "gate_passed": true
+        },
+        "timestamp_missing": {
+          "authentic": {
+            "samples": 3782,
+            "exact_top1": 0.7800105764145955,
+            "family_top1": 0.8553675304071919
+          },
+          "boundary": {
+            "threshold": 0.525,
+            "accuracy": 0.97875,
+            "f1": 0.9789517127527858,
+            "roc_auc": 0.9966340277777778,
+            "single_symbol_recall": 0.9691666666666666,
+            "cross_boundary_recall": 0.9883333333333333
+          },
+          "deltas": {
+            "exact_top1_pp": 0.3437334743521925,
+            "family_top1_pp": -0.6874669487043961
+          },
+          "gate_passed": true
+        },
+        "sparse_sampling": {
+          "authentic": {
+            "samples": 3782,
+            "exact_top1": 0.7723426758328926,
+            "family_top1": 0.8548387096774194
+          },
+          "boundary": {
+            "threshold": 0.525,
+            "accuracy": 0.9791666666666666,
+            "f1": 0.9794069192751236,
+            "roc_auc": 0.99676875,
+            "single_symbol_recall": 0.9675,
+            "cross_boundary_recall": 0.9908333333333333
+          },
+          "deltas": {
+            "exact_top1_pp": -0.4230565838180933,
+            "family_top1_pp": -0.7403490216816522
+          },
+          "gate_passed": true
+        },
+        "affine_device": {
+          "authentic": {
+            "samples": 3782,
+            "exact_top1": 0.7675832892649392,
+            "family_top1": 0.8527234267583289
+          },
+          "boundary": {
+            "threshold": 0.525,
+            "accuracy": 0.9720833333333333,
+            "f1": 0.9722337339411521,
+            "roc_auc": 0.9952104166666667,
+            "single_symbol_recall": 0.9666666666666667,
+            "cross_boundary_recall": 0.9775
+          },
+          "deltas": {
+            "exact_top1_pp": -0.8989952406134316,
+            "family_top1_pp": -0.9518773135906988
+          },
+          "gate_passed": true
+        }
+      },
+      "all_stress_gates_passed": true
+    },
+    {
+      "seed": 31,
+      "threshold": 0.625,
+      "modes": {
+        "clean": {
+          "authentic": {
+            "samples": 3782,
+            "exact_top1": 0.7937599153886833,
+            "family_top1": 0.8770491803278688
+          },
+          "boundary": {
+            "threshold": 0.625,
+            "accuracy": 0.9808333333333333,
+            "f1": 0.9808013355592654,
+            "roc_auc": 0.9979034722222222,
+            "single_symbol_recall": 0.9825,
+            "cross_boundary_recall": 0.9791666666666666
+          }
+        },
+        "coordinate_jitter": {
+          "authentic": {
+            "samples": 3782,
+            "exact_top1": 0.7942887361184559,
+            "family_top1": 0.8778424114225277
+          },
+          "boundary": {
+            "threshold": 0.625,
+            "accuracy": 0.98125,
+            "f1": 0.9811951525282073,
+            "roc_auc": 0.9979090277777778,
+            "single_symbol_recall": 0.9841666666666666,
+            "cross_boundary_recall": 0.9783333333333334
+          },
+          "deltas": {
+            "exact_top1_pp": 0.05288207297725611,
+            "family_top1_pp": 0.07932310946588972
+          },
+          "gate_passed": true
+        },
+        "timestamp_missing": {
+          "authentic": {
+            "samples": 3782,
+            "exact_top1": 0.7911158117398202,
+            "family_top1": 0.8693812797461661
+          },
+          "boundary": {
+            "threshold": 0.625,
+            "accuracy": 0.9791666666666666,
+            "f1": 0.9790444258172674,
+            "roc_auc": 0.9979673611111111,
+            "single_symbol_recall": 0.985,
+            "cross_boundary_recall": 0.9733333333333334
+          },
+          "deltas": {
+            "exact_top1_pp": -0.26441036488631386,
+            "family_top1_pp": -0.7667900581702747
+          },
+          "gate_passed": true
+        },
+        "sparse_sampling": {
+          "authentic": {
+            "samples": 3782,
+            "exact_top1": 0.7890005288207298,
+            "family_top1": 0.8725542041248017
+          },
+          "boundary": {
+            "threshold": 0.625,
+            "accuracy": 0.98125,
+            "f1": 0.9812889812889813,
+            "roc_auc": 0.9979597222222221,
+            "single_symbol_recall": 0.9791666666666666,
+            "cross_boundary_recall": 0.9833333333333333
+          },
+          "deltas": {
+            "exact_top1_pp": -0.4759386567953494,
+            "family_top1_pp": -0.4494976203067158
+          },
+          "gate_passed": true
+        },
+        "affine_device": {
+          "authentic": {
+            "samples": 3782,
+            "exact_top1": 0.7842411422527763,
+            "family_top1": 0.8622421998942359
+          },
+          "boundary": {
+            "threshold": 0.625,
+            "accuracy": 0.9745833333333334,
+            "f1": 0.9743805123897522,
+            "roc_auc": 0.9969861111111111,
+            "single_symbol_recall": 0.9825,
+            "cross_boundary_recall": 0.9666666666666667
+          },
+          "deltas": {
+            "exact_top1_pp": -0.9518773135906988,
+            "family_top1_pp": -1.4806980433632932
+          },
+          "gate_passed": true
+        }
+      },
+      "all_stress_gates_passed": true
+    },
+    {
+      "seed": 47,
+      "threshold": 0.625,
+      "modes": {
+        "clean": {
+          "authentic": {
+            "samples": 3782,
+            "exact_top1": 0.7784241142252777,
+            "family_top1": 0.8646218931782126
+          },
+          "boundary": {
+            "threshold": 0.625,
+            "accuracy": 0.9795833333333334,
+            "f1": 0.9797269342159702,
+            "roc_auc": 0.9966916666666666,
+            "single_symbol_recall": 0.9725,
+            "cross_boundary_recall": 0.9866666666666667
+          }
+        },
+        "coordinate_jitter": {
+          "authentic": {
+            "samples": 3782,
+            "exact_top1": 0.7786885245901639,
+            "family_top1": 0.8654151242728715
+          },
+          "boundary": {
+            "threshold": 0.625,
+            "accuracy": 0.9804166666666667,
+            "f1": 0.9805704836709384,
+            "roc_auc": 0.9966652777777778,
+            "single_symbol_recall": 0.9725,
+            "cross_boundary_recall": 0.9883333333333333
+          },
+          "deltas": {
+            "exact_top1_pp": 0.026441036488622505,
+            "family_top1_pp": 0.07932310946588972
+          },
+          "gate_passed": true
+        },
+        "timestamp_missing": {
+          "authentic": {
+            "samples": 3782,
+            "exact_top1": 0.777895293495505,
+            "family_top1": 0.8622421998942359
+          },
+          "boundary": {
+            "threshold": 0.625,
+            "accuracy": 0.9791666666666666,
+            "f1": 0.9792874896437448,
+            "roc_auc": 0.997129861111111,
+            "single_symbol_recall": 0.9733333333333334,
+            "cross_boundary_recall": 0.985
+          },
+          "deltas": {
+            "exact_top1_pp": -0.052882072977267214,
+            "family_top1_pp": -0.23796932839766916
+          },
+          "gate_passed": true
+        },
+        "sparse_sampling": {
+          "authentic": {
+            "samples": 3782,
+            "exact_top1": 0.7757800105764145,
+            "family_top1": 0.8590692755156002
+          },
+          "boundary": {
+            "threshold": 0.625,
+            "accuracy": 0.97875,
+            "f1": 0.9788994621431527,
+            "roc_auc": 0.9966645833333333,
+            "single_symbol_recall": 0.9716666666666667,
+            "cross_boundary_recall": 0.9858333333333333
+          },
+          "deltas": {
+            "exact_top1_pp": -0.26441036488631386,
+            "family_top1_pp": -0.5552617662612391
+          },
+          "gate_passed": true
+        },
+        "affine_device": {
+          "authentic": {
+            "samples": 3782,
+            "exact_top1": 0.763088313061872,
+            "family_top1": 0.8500793231094659
+          },
+          "boundary": {
+            "threshold": 0.625,
+            "accuracy": 0.9708333333333333,
+            "f1": 0.9708090075062552,
+            "roc_auc": 0.99540625,
+            "single_symbol_recall": 0.9716666666666667,
+            "cross_boundary_recall": 0.97
+          },
+          "deltas": {
+            "exact_top1_pp": -1.5335801163405716,
+            "family_top1_pp": -1.4542570068746707
+          },
+          "gate_passed": true
+        }
+      },
+      "all_stress_gates_passed": true
+    }
+  ],
+  "decision": {
+    "all_seed_stress_gates_passed": true,
+    "failures": [],
+    "product_validation": false
+  },
+  "track": "P_with_obligations",
+  "product_validation": false
+}

scripts/evaluate_math_ink_06_p_boundary_device_stress.py

@@ -0,0 +1,214 @@
+"""채택된 P boundary joint delta를 미관측 device/sampling stress에서 평가한다."""
+
+from __future__ import annotations
+
+import argparse
+from datetime import datetime, timezone
+import json
+from pathlib import Path
+import sys
+
+import torch
+
+PROJECT_ROOT = Path(__file__).parents[1]
+SOURCE_ROOT = PROJECT_ROOT / "src"
+for path in (PROJECT_ROOT, SOURCE_ROOT):
+    if str(path) not in sys.path:
+        sys.path.insert(0, str(path))
+
+from scripts.train_math_ink_06_p_boundary_auxiliary import (
+    _balanced_boundary_set06,
+    _load_encoder06,
+    _load_feature_cache06,
+    _metrics06,
+)
+from scripts.train_math_ink_06_p_boundary_joint import (
+    _authentic_metrics06,
+    _boundary_logits06,
+    _family_target_map06,
+)
+from scripts.train_math_ink_06_skeleton_adapter import _resolve_device06
+
+
+def _parse_args() -> argparse.Namespace:
+    """필요 변수: seed별 base/adapter/head/delta. 작동 원리: 고정 3-seed stress 평가 CLI를 만든다."""
+
+    parser = argparse.ArgumentParser(description="Evaluate Math Ink 0.6 P boundary device stress")
+    parser.add_argument(
+        "--test-cache", type=Path,
+        default=Path(r"D:\Aiflow-CUDA\ink06_feature_cache\paired-paired-test-26bee2f320c6f0a7eca3.pt"),
+    )
+    parser.add_argument("--samples-per-class", type=int, default=1200)
+    parser.add_argument("--batch-size", type=int, default=256)
+    parser.add_argument("--device", choices=("auto", "cpu", "cuda"), default="auto")
+    parser.add_argument("--output", type=Path, required=True)
+    return parser.parse_args()
+
+
+def _sparse_sequence06(sequence: torch.Tensor) -> torch.Tensor:
+    """필요 변수: 128×19 canonical sequence. 작동 원리: raw event 절반을 제거한 뒤 6Hz canonical timeline으로 재보간한다."""
+
+    valid = sequence[sequence[:, 8] >= 0]
+    if len(valid) <= 2:
+        return sequence.clone()
+    anchors = torch.nonzero(valid[:, 7] > 0.5, as_tuple=False).flatten()
+    indices = torch.unique(torch.cat((
+        torch.arange(0, len(valid), 2), anchors, torch.tensor([0, len(valid) - 1]),
+    )), sorted=True)
+    kept = valid[indices].clone()
+    # 좌표·방향·시간 등 연속 channel은 희소 raw event에서 canonical tick으로 선형 복원한다.
+    restored = torch.nn.functional.interpolate(
+        kept.transpose(0, 1).unsqueeze(0), size=len(valid),
+        mode="linear", align_corners=True,
+    ).squeeze(0).transpose(0, 1)
+    # Pen state와 modality/missing 계약은 추정 interpolation 값이 아니라 명시적 anchor를 유지한다.
+    restored[:, 7] = 0.0
+    restored[torch.nonzero(valid[:, 7] > 0.5, as_tuple=False).flatten(), 7] = 1.0
+    restored[:, 17] = valid[:, 17]
+    restored[:, 18] = valid[:, 18]
+    restored[:, 8] = valid[:, 8]
+    output = torch.zeros_like(sequence)
+    output[:, 8] = -1.0
+    output[:len(restored)] = restored
+    return output
+
+
+def _stress06(features: torch.Tensor, mode: str, *, seed: int) -> torch.Tensor:
+    """필요 변수: canonical feature batch·stress mode. 작동 원리: label을 보지 않고 device/sampling 변동만 적용한다."""
+
+    if mode == "clean":
+        return features.clone()
+    output = features.clone()
+    valid = output[:, :, 8] >= 0
+    if mode == "coordinate_jitter":
+        generator = torch.Generator().manual_seed(seed)
+        noise = torch.randn(output.shape[:2] + (2,), generator=generator) * 0.008
+        for columns in ((0, 1), (2, 3)):
+            values = output[:, :, list(columns)]
+            values[valid] = (values[valid] + noise[valid]).clamp(0.0, 1.0)
+            output[:, :, list(columns)] = values
+    elif mode == "timestamp_missing":
+        output[:, :, 15:17] = 0.0
+        output[:, :, 17] = 1.0
+    elif mode == "sparse_sampling":
+        output = torch.stack([_sparse_sequence06(sequence) for sequence in output])
+    elif mode == "affine_device":
+        x = ((output[:, :, 2] - 0.5) * 1.12 + 0.5).clamp(0.0, 1.0)
+        y = ((output[:, :, 3] - 0.5) * 0.88 + 0.5).clamp(0.0, 1.0)
+        output[:, :, 2] = torch.where(valid, x, output[:, :, 2])
+        output[:, :, 3] = torch.where(valid, y, output[:, :, 3])
+        output[:, :, 9] = output[:, :, 9] * (1.12 / 0.88)
+    else:
+        raise ValueError(f"지원하지 않는 stress mode입니다: {mode}")
+    return output
+
+
+def _seed_paths06(seed: int) -> dict[str, Path]:
+    """필요 변수: seed. 작동 원리: 채택된 base·adapter·초기 head·joint delta 경로를 결정한다."""
+
+    boundary_run = (
+        "math_ink_06_p_boundary_auxiliary_layout5_20260724"
+        if seed == 17 else f"math_ink_06_p_boundary_auxiliary_layout5_seed{seed}_20260724"
+    )
+    return {
+        "base": PROJECT_ROOT / f"research/runs/math_ink_06_federated_virtual_ce025_family010_seed{seed}_20260723/math_ink_06_candidate.pt",
+        "adapter": PROJECT_ROOT / f"research/runs/math_ink_06_online_casecontext_refined_seed{seed}_20260723/skeleton_adapter.pt",
+        "boundary": PROJECT_ROOT / f"research/runs/{boundary_run}/boundary_auxiliary_head.pt",
+        "joint": PROJECT_ROOT / f"research/runs/math_ink_06_p_boundary_joint_seed{seed}_20260724/boundary_joint_delta.pt",
+    }
+
+
+def main() -> None:
+    """필요 변수: paired test와 3-seed delta. 작동 원리: clean 대비 stress 회귀를 seed별로 계산하고 최저 gate를 판정한다."""
+
+    args = _parse_args()
+    device = _resolve_device06(args.device)
+    features, targets, cache_key = _load_feature_cache06(args.test_cache)
+    modes = ("clean", "coordinate_jitter", "timestamp_missing", "sparse_sampling", "affine_device")
+    seed_reports = []
+    for seed in (17, 31, 47):
+        paths = _seed_paths06(seed)
+        model, adapter, base, _adapter_payload = _load_encoder06(paths["base"], paths["adapter"], device)
+        boundary = torch.load(paths["boundary"], map_location="cpu", weights_only=True)
+        joint = torch.load(paths["joint"], map_location="cpu", weights_only=True)
+        if not joint["adopted"]:
+            raise ValueError(f"채택되지 않은 joint delta입니다: seed {seed}")
+        if model.boundary_head is None:
+            raise RuntimeError("boundary head가 없습니다.")
+        model.boundary_head.load_state_dict(boundary["state_dict"])
+        model.load_state_dict(joint["state_dict"], strict=False)
+        family_map = _family_target_map06(base)
+        boundary_x, boundary_y = _balanced_boundary_set06(
+            features, targets, samples_per_class=args.samples_per_class, seed=seed + 2,
+        )
+        rows = {}
+        for mode_index, mode in enumerate(modes):
+            authentic_stressed = _stress06(features, mode, seed=seed * 100 + mode_index)
+            boundary_stressed = _stress06(boundary_x, mode, seed=seed * 1000 + mode_index)
+            authentic_metrics = _authentic_metrics06(
+                model, adapter, authentic_stressed, targets, family_map,
+                device=device, batch_size=args.batch_size,
+            )
+            boundary_logits = _boundary_logits06(
+                model, adapter, boundary_stressed, device=device, batch_size=args.batch_size,
+            )
+            boundary_metrics = _metrics06(
+                boundary_logits, boundary_y, threshold=float(joint["threshold"]),
+            )
+            rows[mode] = {"authentic": authentic_metrics, "boundary": boundary_metrics}
+        clean = rows["clean"]
+        for mode in modes[1:]:
+            rows[mode]["deltas"] = {
+                "exact_top1_pp": (
+                    rows[mode]["authentic"]["exact_top1"] - clean["authentic"]["exact_top1"]
+                ) * 100.0,
+                "family_top1_pp": (
+                    rows[mode]["authentic"]["family_top1"] - clean["authentic"]["family_top1"]
+                ) * 100.0,
+            }
+            rows[mode]["gate_passed"] = bool(
+                rows[mode]["deltas"]["exact_top1_pp"] >= -3.0
+                and rows[mode]["deltas"]["family_top1_pp"] >= -3.0
+                and rows[mode]["boundary"]["single_symbol_recall"] >= 0.90
+                and rows[mode]["boundary"]["cross_boundary_recall"] >= 0.90
+            )
+        seed_reports.append({
+            "seed": seed, "threshold": float(joint["threshold"]), "modes": rows,
+            "all_stress_gates_passed": all(rows[mode]["gate_passed"] for mode in modes[1:]),
+        })
+    failures = [
+        {"seed": row["seed"], "mode": mode}
+        for row in seed_reports for mode in modes[1:]
+        if not row["modes"][mode]["gate_passed"]
+    ]
+    report = {
+        "experiment": "P-MATH-INK-06-BOUNDARY-DEVICE-STRESS-001",
+        "generated_at": datetime.now(timezone.utc).isoformat(),
+        "device": str(device),
+        "cuda_device": torch.cuda.get_device_name(device) if device.type == "cuda" else None,
+        "test_cache_key": cache_key,
+        "stress_contract": {
+            "modes": list(modes),
+            "maximum_exact_regression_pp": 3.0,
+            "maximum_family_regression_pp": 3.0,
+            "minimum_single_symbol_recall": 0.90,
+            "minimum_cross_boundary_recall": 0.90,
+        },
+        "seeds": seed_reports,
+        "decision": {
+            "all_seed_stress_gates_passed": not failures,
+            "failures": failures,
+            "product_validation": False,
+        },
+        "track": "P_with_obligations",
+        "product_validation": False,
+    }
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_text(
+        json.dumps(report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8",
+    )
+    print(json.dumps(report, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()