feat: payload size matrix benchmark + archive completed subtask artifacts

2026-06-03 06:15:52 +09:00 · 2026-06-03 06:15:52 +09:00 · 73a0d4b20b
commit 73a0d4b20b
parent 9a02a13dc5
15 changed files with 1138 additions and 47 deletions
--- a/agent-ops/skills/project/run-proto-socket-test-matrix/scripts/run_stress.sh
+++ b/agent-ops/skills/project/run-proto-socket-test-matrix/scripts/run_stress.sh
@ -27,6 +27,8 @@ Profiles (comma separated, default: per-language all):
  burst      single-connection fire-and-forget burst ordering / leak check
  sustained  time-boxed sustained request-response with peak memory
  parallel   multi-connection FIFO / nonce isolation
+  payload    payload size matrix request-response (quick: 1KB/64KB, full: 1KB/64KB/1MB)
+             with per-payload latency, throughput, peak memory, stability counters
  cross      cross-language request-response correctness / stability adapter
  gateway    (TypeScript only) worker_threads gateway on/off frame-ingest baseline

--- a/agent-task/archive/2026/06/m-high-performance-parallel-operations/03+01_payload_matrix/code_review_cloud_G08_0.log
+++ b/agent-task/archive/2026/06/m-high-performance-parallel-operations/03+01_payload_matrix/code_review_cloud_G08_0.log
@ -0,0 +1,91 @@
+<!-- task=m-high-performance-parallel-operations/03+01_payload_matrix plan=0 tag=PAYLOAD_MATRIX -->
+
+# Code Review Reference - PAYLOAD_MATRIX
+
+> **[IMPLEMENTING AGENT - READ FIRST] Filling in this file is the mandatory final step of implementation.**
+
+## 구현 체크리스트
+
+- [x] `01_lang_baseline` 완료 근거를 확인한다.
+- [x] payload size matrix를 추가한다. 검증: 1KB, 64KB, 1MB payload에서 latency, throughput, memory peak, gateway backlog가 기록된다.
+- [x] quick mode는 작은 샘플, full mode는 Milestone 기준 payload matrix를 실행하도록 한다.
+- [x] payload별 결과 row가 공통 schema의 `Payload(bytes)`와 stability counters를 채운다.
+- [x] CODE_REVIEW-*-G??.md의 구현 에이전트 소유 섹션을 실제 구현 내용과 검증 출력으로 채운다. 이 항목이 완료되기 전에는 구현이 완료된 것이 아니다.
+
+## 구현 메모
+
+- 변경 파일:
+  - `typescript/bench/stress.ts` — `payload` profile 추가(PAYLOAD_MATRIX-1). `ALL_PROFILES`/`TRANSPORT_PROFILES`에 `payload` 등록, `payloadFiller`/`payloadLabel` helper, `profilePayload` 추가, `transportRunners`에 연결.
+  - `go/bench/stress.go` — `payload` profile 추가. `allProfiles`/runners 등록, `payloadFiller`/`payloadLabel`, `profilePayload`. Go WS는 nhooyr 기본 32KiB read limit 때문에 ~32KB 초과 WS payload를 deferred SKIP으로 남긴다.
+  - `python/bench/stress.py` — `payload` profile 추가. `ALL_PROFILES`/`RUNNERS` 등록, `payload_filler`/`payload_label`, `profile_payload`.
+  - `dart/bench/stress.dart` — `payload` profile 추가. `_allProfiles`/`_runners` 등록, `_payloadFiller`/`_payloadLabel`, `_profilePayload`.
+  - `kotlin/crosstest/stress.kt` — `payload` profile 추가. `ALL_PROFILES`/runners 등록, `payloadFiller`/`payloadLabel`, `sendPayloadOne`, `profilePayload`. 기존 `deferredBottleneck`을 재사용해 Kotlin TCP(delayed-ACK)는 deferred로 남기고 WS만 측정한다.
+  - `agent-ops/skills/project/run-proto-socket-test-matrix/scripts/run_stress.sh` — usage Profiles 목록에 `payload` 설명 추가. orchestrator는 `--profile payload`를 각 언어 harness에 그대로 전달하므로 추가 로직 변경 없음.
+- 주요 결정:
+  - payload profile은 4개 공통 profile(roundtrip/burst/sustained/parallel)과 같은 5개 언어 공통 축으로 구현했다(gateway만 TypeScript 전용 유지). request-response 기반으로 만들어 payload별 p50/p95/p99 latency, throughput, peak memory를 한 번에 측정한다.
+  - payload sizes: quick=[1KB, 64KB], full=[1KB, 64KB, 1MB]. concurrency quick=4/full=8, requests/size quick=20/full=100. `Payload(bytes)` 열에는 deterministic filler(`0123456789abcdef` 반복)로 채운 message의 실제 serialized payload bytes를 기록한다.
+  - 두 transport 한계는 라이브러리 수정 없이 기존 deferred 패턴으로 surface했다(라이브러리 변경은 본 subtask 범위 밖, optimize Epic 대상): (1) Go WS는 nhooyr 기본 32KiB read limit으로 ~32KB 초과 WS payload를 deferred SKIP, (2) Kotlin TCP는 기존 `deferredBottleneck`의 delayed-ACK 한계로 deferred(WS만 측정).
+- 계획 대비 변경:
+  - 계획의 `quick payload smoke` 중간 검증 명령은 `--quick --profile payload`로 그대로 따랐다. payload helper를 별도 파일이 아니라 각 언어 stress harness 내부 함수로 추가해 기존 구조(공통 profile들과 동일 위치)를 따랐다.
+  - 계획에 없던 사항으로, payload 축에서만 드러나는 Go WS 32KiB / Kotlin TCP delayed-ACK 한계를 deferred로 명시 기록했다(stability 위반이 아니라 baseline 미완결 표시).
+
+## 검증 결과
+
+- 실행 명령:
+  - `bash agent-ops/skills/project/run-proto-socket-test-matrix/scripts/run_stress.sh --quick --profile payload`
+  - `cd typescript && npm run check && npm test`
+  - `bash agent-ops/skills/project/run-proto-socket-test-matrix/scripts/run_matrix.sh --all`
+  - `git diff --check`
+- 결과 기록 파일:
+  - payload stress quick: `agent-test/runs/20260602-203309-proto-socket-stress-quick.md`
+  - full matrix: `agent-test/runs/20260602-203419-proto-socket-full-matrix.md`
+- stdout/stderr 요약:
+  - payload stress quick: 측정된 모든 payload row(TS/Go/Python/Dart tcp·ws 1KB·64KB, Kotlin ws 1KB·64KB)가 `Payload(bytes)`(예: 1027/65540)와 p50/p95/p99/throughput/peak memory를 채우고 stability_violations=0. 전체 결과값은 `INCOMPLETE`(exit 4)이며 사유는 stability 실패가 아니라 문서화된 deferred 2건뿐: Kotlin tcp(required SKIP 2, delayed-ACK) + Go ws 64KB(required SKIP 1, nhooyr 32KiB read limit). 이는 기존 lang-baseline의 Kotlin TCP deferred와 동일한 baseline 미완결 표기다.
+  - full matrix: exit 0, schema sync PASS, 동일언어 5개 PASS, 언어 PASS 매트릭스(Dart.io/Dart.web/Dart.web(WSS)/Go/Kotlin/Python/TypeScript) 전부 PASS, 크로스테스트 일반 방향 16/16, Dart.web·Dart.web(WSS) 방향 2/2 모두 PASS. payload 변경은 bench harness 한정이라 protocol/crosstest 매트릭스에 영향 없음을 재확인.
+  - TypeScript: `tsc --noEmit` 통과, vitest 50/50 통과.
+  - `git diff --check`: whitespace 오류 없음.
+- 미실행 항목:
+  - `--full` payload(1MB 포함) 전체 실행은 수행하지 않았다. quick으로 1KB/64KB 측정 경로와 stability gate를 확인했고, full 1MB 경로는 동일 코드 경로에 size만 추가되는 형태다. 후속 에이전트가 `run_stress.sh --full --profile payload` 재실행으로 1MB row까지 수집 가능하다(자동 후속 가능, 사용자 리뷰 요청 아님).
+
+## 사용자 리뷰 요청
+
+_기본값은 `없음`이다. 구현 중 사용자 결정, 사용자 소유 외부 환경/secret/서비스 준비, 또는 계획 범위 변경 없이는 안전하게 진행할 수 없으면 아래 항목을 실제 내용으로 교체하고, 구현을 중단한 뒤 active 파일을 그대로 둔 채 리뷰를 요청한다. 후속 에이전트가 명령 재실행이나 산출물 수집으로 해소할 수 있는 검증 증거 공백만으로는 사용자 리뷰 요청을 작성하지 않는다._
+
+- 상태: 없음
+- 사유 유형: 없음
+- 결정 필요: 없음
+- 차단 근거: 없음
+- 실행한 검증/명령: 없음
+- 자동 후속 불가 이유: 없음
+- 재개 조건: 없음
+
+## 코드리뷰 결과
+
+- 종합 판정: FAIL
+- 차원별 평가:
+  - correctness: Pass
+  - completeness: Fail
+  - test coverage: Fail
+  - API contract: Pass
+  - code quality: Pass
+  - plan deviation: Fail
+  - verification trust: Fail
+- 발견된 문제:
+  - Required: [agent-task/m-high-performance-parallel-operations/03+01_payload_matrix/CODE_REVIEW-cloud-G08.md](/config/workspace/proto-socket/agent-task/m-high-performance-parallel-operations/03+01_payload_matrix/CODE_REVIEW-cloud-G08.md:47) marks the integrated payload matrix checklist complete while explicitly stating that `--full` payload, the only evidence path that includes 1MB rows, was not run. The planned item requires 1KB, 64KB, and 1MB payload rows with latency, throughput, memory peak, gateway backlog/common schema fields before completion ([PLAN-cloud-G08.md](/config/workspace/proto-socket/agent-task/m-high-performance-parallel-operations/03+01_payload_matrix/PLAN-cloud-G08.md:67)). Fix: run `bash agent-ops/skills/project/run-proto-socket-test-matrix/scripts/run_stress.sh --full --profile payload`, record the generated result file, and update the review evidence with the actual 1MB rows or concrete failures/deferred axes.
+  - Required: [agent-task/m-high-performance-parallel-operations/03+01_payload_matrix/CODE_REVIEW-cloud-G08.md](/config/workspace/proto-socket/agent-task/m-high-performance-parallel-operations/03+01_payload_matrix/CODE_REVIEW-cloud-G08.md:42) provides summaries and result-file references, but not the actual stdout/stderr required by the review stub. Fix: paste the relevant command stdout/stderr tails or exact saved evidence paths for the quick/full payload, TypeScript check/test, full matrix, and `git diff --check` commands so a reviewer can verify the claims deterministically.
+- 다음 단계: WARN/FAIL 후속 plan/review를 작성한다.
+
+## 코드리뷰 전용 체크리스트
+
+- [x] `코드리뷰 결과`에 `PASS`, `WARN`, `FAIL` 중 하나의 판정을 append한다.
+- [x] 판정과 `차원별 평가`, Required/Suggested/Nit 분류가 서로 일치한다.
+- [x] active `CODE_REVIEW-*-G??.md`를 `code_review_{review_lane}_GNN_N.log`로 아카이브한다.
+- [x] active `PLAN-*-G??.md`를 `plan_{build_lane}_GNN_M.log`로 아카이브한다.
+- [x] `.gitignore`의 Agent-Ops 관리 block이 `agent-task/**/*.md`와 `agent-task/**/*.log`를 unignore하여 plan/review/archive 산출물이 추적 가능한지 확인한다.
+- [ ] PASS이면 `agent-ops/skills/common/code-review/templates/complete-log-template.md` 기준으로 `complete.log`를 작성하고 active `.md` 파일을 남기지 않는다.
+- [ ] PASS이면 active task 디렉터리 `agent-task/{task_name}/`를 `agent-task/archive/YYYY/MM/{task_name}/`로 이동하고 최종 archive 경로에서 이 체크리스트를 갱신한다.
+- [ ] PASS이고 task group이 `m-<milestone-slug>`이면 런타임이 읽을 완료 이벤트 메타데이터를 보고하고, roadmap 수정이나 `update-roadmap` 직접 호출을 하지 않는다.
+- [ ] PASS split 작업이면 이동 후 빈 active parent `agent-task/{task_group}/`를 제거하거나, 남은 sibling/file이 있어 유지했다고 확인한다.
+- [x] WARN/FAIL이고 user-review gate가 트리거되지 않았으면 다음 active `PLAN-{build_lane}-GNN.md`와 `CODE_REVIEW-{review_lane}-GNN.md`를 작성하고 `complete.log`를 작성하지 않는다.
+- [ ] USER_REVIEW이면 `agent-ops/skills/common/code-review/templates/user-review-template.md` 기준으로 `USER_REVIEW.md`를 작성하고 active `PLAN-*.md`, `CODE_REVIEW-*.md`, `complete.log`를 남기지 않는다.
+- [ ] USER_REVIEW가 사용자 결정으로 완료/PASS 해소되면 `USER_REVIEW.md`를 해소 상태로 갱신하고 `complete.log`를 작성한 뒤 task directory를 archive로 이동한다.
--- a/agent-task/archive/2026/06/m-high-performance-parallel-operations/03+01_payload_matrix/code_review_cloud_G08_1.log
+++ b/agent-task/archive/2026/06/m-high-performance-parallel-operations/03+01_payload_matrix/code_review_cloud_G08_1.log
@ -0,0 +1,220 @@
+<!-- task=m-high-performance-parallel-operations/03+01_payload_matrix plan=1 tag=REVIEW_PAYLOAD_MATRIX -->
+
+# Code Review Reference - REVIEW_PAYLOAD_MATRIX
+
+> **[IMPLEMENTING AGENT - READ FIRST] Filling in this file is the mandatory final step of implementation.**
+
+## Roadmap Targets
+
+- Milestone: `agent-roadmap/milestones/high-performance-parallel-operations.md`
+- Task ids:
+  - `payload-matrix`: payload size matrix를 추가한다.
+- Completion mode: check-on-pass
+
+## 구현 항목별 완료 여부
+
+| 항목 | 완료 여부 |
+|------|---------|
+| [REVIEW_PAYLOAD_MATRIX-1] full payload evidence 복구 | [x] |
+| [REVIEW_PAYLOAD_MATRIX-2] 리뷰 증거 기록 보강 | [x] |
+
+## 구현 체크리스트
+
+- [x] full payload matrix를 실행하고 1KB, 64KB, 1MB row 또는 required SKIP/BLOCKED 축을 결과 파일에 기록한다.
+- [x] `CODE_REVIEW-cloud-G08.md`에 quick/full payload, TypeScript check/test, full matrix, `git diff --check`의 실제 stdout/stderr tail 또는 정확한 저장 evidence path를 기록한다.
+- [x] full payload 실행에서 코드 결함이 확인되면 최소 범위로 수정하고 관련 검증을 재실행한다.
+- [x] payload별 결과 row가 공통 schema의 `Payload(bytes)`와 stability counters를 채우는지 결과 파일 기준으로 확인한다.
+- [x] CODE_REVIEW-*-G??.md의 구현 에이전트 소유 섹션을 실제 구현 내용과 검증 출력으로 채운다. 이 항목이 완료되기 전에는 구현이 완료된 것이 아니다.
+
+## 코드리뷰 전용 체크리스트
+
+> **[REVIEW AGENT ONLY]** 이 체크리스트는 코드리뷰 에이전트만 사용한다.
+
+- [x] `코드리뷰 결과`에 `PASS`, `WARN`, `FAIL` 중 하나의 판정을 append한다.
+- [x] 판정과 `차원별 평가`, Required/Suggested/Nit 분류가 서로 일치한다.
+- [x] active `CODE_REVIEW-*-G??.md`를 `code_review_{review_lane}_GNN_N.log`로 아카이브한다.
+- [x] active `PLAN-*-G??.md`를 `plan_{build_lane}_GNN_M.log`로 아카이브한다.
+- [x] `.gitignore`의 Agent-Ops 관리 block이 `agent-task/**/*.md`와 `agent-task/**/*.log`를 unignore하여 plan/review/archive 산출물이 추적 가능한지 확인한다.
+- [x] PASS이면 `agent-ops/skills/common/code-review/templates/complete-log-template.md` 기준으로 `complete.log`를 작성하고 active `.md` 파일을 남기지 않는다.
+- [x] PASS이면 active task 디렉터리 `agent-task/{task_name}/`를 `agent-task/archive/YYYY/MM/{task_name}/`로 이동하고 최종 archive 경로에서 이 체크리스트를 갱신한다.
+- [x] PASS이고 task group이 `m-<milestone-slug>`이면 런타임이 읽을 완료 이벤트 메타데이터를 보고하고, roadmap 수정이나 `update-roadmap` 직접 호출을 하지 않는다.
+- [x] PASS split 작업이면 이동 후 빈 active parent `agent-task/{task_group}/`를 제거하거나, 남은 sibling/file이 있어 유지했다고 확인한다.
+- [ ] WARN/FAIL이고 user-review gate가 트리거되지 않았으면 다음 active `PLAN-{build_lane}-GNN.md`와 `CODE_REVIEW-{review_lane}-GNN.md`를 작성하고 `complete.log`를 작성하지 않는다.
+- [ ] USER_REVIEW이면 `agent-ops/skills/common/code-review/templates/user-review-template.md` 기준으로 `USER_REVIEW.md`를 작성하고 active `PLAN-*.md`, `CODE_REVIEW-*.md`, `complete.log`를 남기지 않는다.
+- [ ] USER_REVIEW가 사용자 결정으로 완료/PASS 해소되면 `USER_REVIEW.md`를 해소 상태로 갱신하고 `complete.log`를 작성한 뒤 task directory를 archive로 이동한다.
+
+## 구현 메모
+
+- 변경 파일:
+  - `python/proto_socket/ws_client.py`
+  - `python/proto_socket/ws_server.py`
+  - `python/test/test_ws.py`
+  - 기존 payload stress harness 변경 파일: `agent-ops/skills/project/run-proto-socket-test-matrix/scripts/run_stress.sh`, `dart/bench/stress.dart`, `go/bench/stress.go`, `kotlin/crosstest/stress.kt`, `python/bench/stress.py`, `typescript/bench/stress.ts`
+- 주요 결정:
+  - full payload 실행에서 Python WS 1MB만 `NonceMis=100`으로 실패했다. protobuf 프레임 크기 1,048,580 bytes가 `websockets` 기본 `max_size` 1MiB를 4 bytes 초과한 것이므로, Python WS client/server 모두 기존 TCP `MAX_PACKET_SIZE` 64MiB를 사용하도록 맞췄다.
+  - Go WS 64KB/1MB는 nhooyr 기본 32KiB read limit, Kotlin TCP 1KB/64KB/1MB는 delayed-ACK latency-bound 사유로 기존 계획의 required SKIP을 유지했다.
+- 계획 대비 변경:
+  - full payload에서 실제 코드 결함이 확인되어 Python WS만 최소 수정했고, Python 회귀 테스트와 full payload/full matrix를 재실행했다.
+
+## 사용자 리뷰 요청
+
+_기본값은 `없음`이다. 구현 중 사용자 결정, 사용자 소유 외부 환경/secret/서비스 준비, 또는 계획 범위 변경 없이는 안전하게 진행할 수 없으면 아래 항목을 실제 내용으로 교체하고, 구현을 중단한 뒤 active 파일을 그대로 둔 채 리뷰를 요청한다. 후속 에이전트가 명령 재실행이나 산출물 수집으로 해소할 수 있는 검증 증거 공백만으로는 사용자 리뷰 요청을 작성하지 않는다._
+
+- 상태: 없음
+- 사유 유형: 없음
+- 결정 필요: 없음
+- 차단 근거: 없음
+- 실행한 검증/명령: 없음
+- 자동 후속 불가 이유: 없음
+- 재개 조건: 없음
+
+## 리뷰어를 위한 체크포인트
+
+- full payload 결과 파일에 1MB row 또는 명시적 SKIP/BLOCKED 축이 남았는지 확인한다.
+- full payload 실행 결과가 FAIL이면 코드 결함 수정과 재실행 evidence가 있는지 확인한다.
+- quick/full payload, TypeScript check/test, full matrix, `git diff --check` 증거가 요약만이 아니라 실제 stdout/stderr tail 또는 정확한 저장 경로로 남았는지 확인한다.
+- Roadmap Targets의 `payload-matrix`는 PASS일 때만 complete.log에 복사한다.
+
+## 검증 결과
+
+_구현 에이전트가 각 중간 검증 및 최종 검증 명령 실행 후 출력을 여기에 붙여 넣는다._
+
+### REVIEW_PAYLOAD_MATRIX-1 중간 검증
+
+```bash
+bash agent-ops/skills/project/run-proto-socket-test-matrix/scripts/run_stress.sh --full --profile payload
+```
+
+1차 실행 결과:
+
+- 결과 파일: `agent-test/runs/20260602-205637-proto-socket-stress-full.md`
+- 전체 결과값: `FAIL`
+- 실패 축: `payload=1MB | Python | ws | Payload(bytes)=1048580 | Requests=0 | NonceMis=100 | FAIL`
+- 조치: Python WS client/server의 `websockets` `max_size`를 TCP `MAX_PACKET_SIZE`와 동일하게 설정하고 1MB WS request/response 테스트를 추가했다.
+
+수정 후 재실행 결과:
+
+- 결과 파일: `agent-test/runs/20260602-205755-proto-socket-stress-full.md`
+- 전체 결과값: `INCOMPLETE`
+- 판정 근거: stability violation은 0이고, INCOMPLETE는 기존 required SKIP 축 때문이다.
+
+```text
+전체 결과값: INCOMPLETE
+결과 기록 파일: agent-test/runs/20260602-205755-proto-socket-stress-full.md
+DONE dart: PASS (rows=6 skips=0 required_skips=0 violations=0)
+DONE go: INCOMPLETE (rows=4 skips=2 required_skips=2 violations=0)
+DONE kotlin: INCOMPLETE (rows=3 skips=3 required_skips=3 violations=0)
+DONE python: PASS (rows=6 skips=0 required_skips=0 violations=0)
+DONE typescript: PASS (rows=6 skips=0 required_skips=0 violations=0)
+```
+
+1MB row/SKIP 발췌:
+
+```text
+| payload | payload=1MB | Dart | tcp | 1048582 | 1 | 100 | ... | Timeout=0 | NonceMis=0 | TypeMis=0 | FIFOViol=0 | PendLeak=0 | PASS |
+| payload | payload=1MB | Dart | ws | 1048582 | 1 | 100 | ... | Timeout=0 | NonceMis=0 | TypeMis=0 | FIFOViol=0 | PendLeak=0 | PASS |
+| payload | payload=1MB | Go | tcp | 1048580 | 1 | 100 | ... | Timeout=0 | NonceMis=0 | TypeMis=0 | FIFOViol=0 | PendLeak=0 | PASS |
+| payload | payload=1MB | Kotlin | ws | 1048580 | 1 | 100 | ... | Timeout=0 | NonceMis=0 | TypeMis=0 | FIFOViol=0 | PendLeak=0 | PASS |
+| payload | payload=1MB | Python | tcp | 1048580 | 1 | 100 | ... | Timeout=0 | NonceMis=0 | TypeMis=0 | FIFOViol=0 | PendLeak=0 | PASS |
+| payload | payload=1MB | Python | ws | 1048580 | 1 | 100 | ... | Timeout=0 | NonceMis=0 | TypeMis=0 | FIFOViol=0 | PendLeak=0 | PASS |
+| payload | payload=1MB | TypeScript | tcp | 1048580 | 1 | 100 | ... | Timeout=0 | NonceMis=0 | TypeMis=0 | FIFOViol=0 | PendLeak=0 | PASS |
+| payload | payload=1MB | TypeScript | ws | 1048580 | 1 | 100 | ... | Timeout=0 | NonceMis=0 | TypeMis=0 | FIFOViol=0 | PendLeak=0 | PASS |
+| required | payload | payload=1MB | Go | ws | deferred: optimize Epic - Go WsClient/WsServer keep the nhooyr default 32KiB read limit |
+| required | payload | payload=1MB | Kotlin | tcp | deferred: optimize Epic - Kotlin TcpClient without TCP_NODELAY is delayed-ACK latency-bound |
+```
+
+### REVIEW_PAYLOAD_MATRIX-2 중간 검증
+
+```bash
+rg --sort path "payload=1MB|overall_result|SKIPPED/BLOCKED|stability_violations" agent-test/runs
+```
+
+최신 full payload evidence:
+
+```text
+agent-test/runs/20260602-205755-proto-socket-stress-full.md:6:overall_result: INCOMPLETE
+agent-test/runs/20260602-205755-proto-socket-stress-full.md:46:| payload | payload=1MB | Dart | tcp | 1048582 | ... | PASS |
+agent-test/runs/20260602-205755-proto-socket-stress-full.md:49:| payload | payload=1MB | Dart | ws | 1048582 | ... | PASS |
+agent-test/runs/20260602-205755-proto-socket-stress-full.md:52:| payload | payload=1MB | Go | tcp | 1048580 | ... | PASS |
+agent-test/runs/20260602-205755-proto-socket-stress-full.md:56:| payload | payload=1MB | Kotlin | ws | 1048580 | ... | PASS |
+agent-test/runs/20260602-205755-proto-socket-stress-full.md:59:| payload | payload=1MB | Python | tcp | 1048580 | ... | PASS |
+agent-test/runs/20260602-205755-proto-socket-stress-full.md:62:| payload | payload=1MB | Python | ws | 1048580 | ... | PASS |
+agent-test/runs/20260602-205755-proto-socket-stress-full.md:65:| payload | payload=1MB | TypeScript | tcp | 1048580 | ... | PASS |
+agent-test/runs/20260602-205755-proto-socket-stress-full.md:68:| payload | payload=1MB | TypeScript | ws | 1048580 | ... | PASS |
+agent-test/runs/20260602-205755-proto-socket-stress-full.md:77:| required | payload | payload=1MB | Go | ws | deferred: optimize Epic - Go WS 32KiB read limit |
+agent-test/runs/20260602-205755-proto-socket-stress-full.md:80:| required | payload | payload=1MB | Kotlin | tcp | deferred: optimize Epic - delayed-ACK latency-bound |
+```
+
+quick payload evidence:
+
+- 결과 파일: `agent-test/runs/20260602-205828-proto-socket-stress-quick.md`
+- 전체 결과값: `INCOMPLETE`
+- 1KB/64KB 측정 row는 Dart, Python, TypeScript tcp/ws 및 Go tcp/ws(1KB), Go tcp(64KB), Kotlin ws 모두 `PASS`.
+- required SKIP: Go ws 64KB, Kotlin tcp 1KB/64KB. 모든 측정 row의 stability counters는 0.
+
+### 최종 검증
+
+```bash
+bash agent-ops/skills/project/run-proto-socket-test-matrix/scripts/run_stress.sh --full --profile payload
+cd typescript && npm run check && npm test
+bash agent-ops/skills/project/run-proto-socket-test-matrix/scripts/run_matrix.sh --all
+git diff --check
+```
+
+추가 Python 회귀 검증:
+
+```text
+$ cd python && python3 -m pytest -q
+35 passed in 1.16s
+```
+
+TypeScript check/test:
+
+```text
+$ cd typescript && npm run check && npm test
+> proto-socket@1.0.5 check
+> tsc --noEmit
+> proto-socket@1.0.5 test
+> vitest run
+Test Files  5 passed (5)
+Tests  50 passed (50)
+```
+
+full matrix:
+
+- 결과 파일: `agent-test/runs/20260602-205849-proto-socket-full-matrix.md`
+- 전체 결과값: `PASS`
+- stdout/stderr tail 근거:
+
+```text
+Proto 동기화: PASS
+Dart: PASS
+Go: PASS
+Kotlin: PASS
+Python: PASS
+TypeScript: PASS
+언어 PASS 매트릭스: all PASS
+크로스테스트 상세: 일반 cross 16/16 all PASS, Dart.web/Dart.web(WSS) 2/2 all PASS
+로그 디렉터리: /tmp/proto-socket-matrix.62zJcg
+```
+
+git diff whitespace check:
+
+```text
+$ git diff --check
+<no output>
+```
+
+## 코드리뷰 결과
+
+- 종합 판정: PASS
+- 차원별 평가:
+  - correctness: Pass
+  - completeness: Pass
+  - test coverage: Pass
+  - API contract: Pass
+  - code quality: Pass
+  - plan deviation: Pass
+  - verification trust: Pass
+- 발견된 문제: 없음
+- 다음 단계: PASS이므로 `complete.log` 작성 후 task directory를 archive로 이동한다.
--- a/agent-task/archive/2026/06/m-high-performance-parallel-operations/03+01_payload_matrix/complete.log
+++ b/agent-task/archive/2026/06/m-high-performance-parallel-operations/03+01_payload_matrix/complete.log
@ -0,0 +1,46 @@
+# Complete - m-high-performance-parallel-operations/03+01_payload_matrix
+
+## 완료 일시
+
+2026-06-03
+
+## 요약
+
+payload size matrix follow-up까지 2회 리뷰 루프로 완료했다. 최종 판정 PASS.
+
+## 루프 이력
+
+| Plan | Review | Verdict | 메모 |
+|------|--------|---------|------|
+| `plan_cloud_G08_0.log` | `code_review_cloud_G08_0.log` | FAIL | 1MB full payload evidence와 실제 stdout/stderr 기록이 없어 verification trust/completeness 미충족 |
+| `plan_cloud_G08_1.log` | `code_review_cloud_G08_1.log` | PASS | full payload evidence 복구, Python WS 1MB max_size 수정, 회귀/전체 매트릭스 검증 완료 |
+
+## 구현/정리 내용
+
+- Dart, Go, Kotlin, Python, TypeScript stress harness에 payload profile을 추가해 quick 1KB/64KB, full 1KB/64KB/1MB payload rows를 기록한다.
+- Go WS 64KB/1MB와 Kotlin TCP payload 축은 기존 transport 병목 정책에 따라 required SKIP으로 기록하고 stability violation으로 오인하지 않게 했다.
+- Python WS client/server의 `websockets` `max_size`를 TCP `MAX_PACKET_SIZE`와 맞춰 1MB protobuf frame request/response가 통과하도록 수정했다.
+- Python WS large payload request-response 회귀 테스트를 추가했다.
+
+## 최종 검증
+
+- `bash agent-ops/skills/project/run-proto-socket-test-matrix/scripts/run_stress.sh --full --profile payload` - INCOMPLETE by expected required SKIP only; result=`agent-test/runs/20260602-205755-proto-socket-stress-full.md`; measured rows have stability counters 0, Python WS 1MB PASS, Go WS 64KB/1MB and Kotlin TCP 1KB/64KB/1MB remain deferred SKIP.
+- `cd python && python3 -m pytest -q` - PASS; `35 passed in 1.15s` in review rerun.
+- `cd typescript && npm run check && npm test` - PASS; recorded in `code_review_cloud_G08_1.log`, TypeScript tests 50/50 PASS.
+- `bash agent-ops/skills/project/run-proto-socket-test-matrix/scripts/run_matrix.sh --all` - PASS; result=`agent-test/runs/20260602-205849-proto-socket-full-matrix.md`.
+- `git diff --check` - PASS; no output in review rerun.
+
+## Roadmap Completion
+
+- Milestone: `agent-roadmap/milestones/high-performance-parallel-operations.md`
+- Completed task ids:
+  - `payload-matrix`: PASS; evidence=`plan_cloud_G08_1.log`, `code_review_cloud_G08_1.log`; verification=`agent-test/runs/20260602-205755-proto-socket-stress-full.md`, `agent-test/runs/20260602-205849-proto-socket-full-matrix.md`, `cd python && python3 -m pytest -q`, `git diff --check`
+- Not completed task ids: 없음
+
+## 잔여 Nit
+
+- 없음
+
+## 후속 작업
+
+- 없음
--- a/agent-task/archive/2026/06/m-high-performance-parallel-operations/03+01_payload_matrix/plan_cloud_G08_0.log
+++ b/agent-task/archive/2026/06/m-high-performance-parallel-operations/03+01_payload_matrix/plan_cloud_G08_0.log
--- a/agent-task/archive/2026/06/m-high-performance-parallel-operations/03+01_payload_matrix/plan_cloud_G08_1.log
+++ b/agent-task/archive/2026/06/m-high-performance-parallel-operations/03+01_payload_matrix/plan_cloud_G08_1.log
@ -0,0 +1,124 @@
+<!-- task=m-high-performance-parallel-operations/03+01_payload_matrix plan=1 tag=REVIEW_PAYLOAD_MATRIX -->
+
+# Plan - REVIEW_PAYLOAD_MATRIX
+
+## 이 파일을 읽는 구현 에이전트에게
+
+`code_review_cloud_G08_0.log`의 Required 이슈만 해결한다. 코드 변경은 full payload 실행에서 실제 실패가 확인될 때만 최소 범위로 수행하고, 마지막에 `CODE_REVIEW-cloud-G08.md`의 구현 에이전트 소유 섹션을 실제 검증 출력으로 채운다.
+
+## 배경
+
+1차 리뷰는 payload profile 구현 자체보다 검증 완결성과 증거 기록을 실패로 판정했다. 계획의 통합 검증 항목은 1KB, 64KB, 1MB payload row 기록을 요구하지만, 구현 증거는 quick 1KB/64KB만 포함했고 active review에는 실제 stdout/stderr 대신 요약만 남았다.
+
+## 사용자 리뷰 요청 흐름
+
+구현 중 사용자 결정이나 외부 환경 준비가 필요한 경우 review stub의 `사용자 리뷰 요청` 섹션에 기록한다. 단, full payload 실행 실패, timeout, 또는 증거 공백은 먼저 자동 후속으로 재실행/수집한다.
+
+## Roadmap Targets
+
+- Milestone: `agent-roadmap/milestones/high-performance-parallel-operations.md`
+- Task ids:
+  - `payload-matrix`: payload size matrix를 추가한다.
+- Completion mode: check-on-pass
+
+## 분석 결과
+
+### 읽은 파일
+
+- `agent-task/m-high-performance-parallel-operations/03+01_payload_matrix/plan_cloud_G08_0.log`
+- `agent-task/m-high-performance-parallel-operations/03+01_payload_matrix/code_review_cloud_G08_0.log`
+- `agent-test/runs/20260602-203309-proto-socket-stress-quick.md`
+- `agent-test/runs/20260602-203419-proto-socket-full-matrix.md`
+
+### 범위 결정 근거
+
+- 후속 범위는 verification trust/completeness 복구로 제한한다.
+- full payload 실행에서 1MB 관련 실제 코드 실패가 발견되면 해당 실패를 고치는 최소 코드 변경만 허용한다.
+- Go WS 32KiB read limit, Kotlin TCP delayed-ACK deferred 정책 자체를 바꾸는 작업은 optimize Epic 범위이므로 이번 후속에서 기본 정책을 바꾸지 않는다. 다만 full payload 결과에서 어떤 축이 측정/skip됐는지는 정확히 기록한다.
+
+### 빌드 등급
+
+- build=`cloud-G08`, review=`cloud-G08`. terminal benchmark evidence와 full payload 결과 신뢰성 복구가 핵심이다.
+
+## 구현 체크리스트
+
+- [x] full payload matrix를 실행하고 1KB, 64KB, 1MB row 또는 required SKIP/BLOCKED 축을 결과 파일에 기록한다.
+- [x] `CODE_REVIEW-cloud-G08.md`에 quick/full payload, TypeScript check/test, full matrix, `git diff --check`의 실제 stdout/stderr tail 또는 정확한 저장 evidence path를 기록한다.
+- [x] full payload 실행에서 코드 결함이 확인되면 최소 범위로 수정하고 관련 검증을 재실행한다.
+- [x] payload별 결과 row가 공통 schema의 `Payload(bytes)`와 stability counters를 채우는지 결과 파일 기준으로 확인한다.
+- [x] CODE_REVIEW-*-G??.md의 구현 에이전트 소유 섹션을 실제 구현 내용과 검증 출력으로 채운다. 이 항목이 완료되기 전에는 구현이 완료된 것이 아니다.
+
+### [REVIEW_PAYLOAD_MATRIX-1] full payload evidence 복구
+
+#### 문제
+
+[code_review_cloud_G08_0.log](/config/workspace/proto-socket/agent-task/m-high-performance-parallel-operations/03+01_payload_matrix/code_review_cloud_G08_0.log:72)는 `--full` payload 미실행을 명시한다. 이 상태에서는 [plan_cloud_G08_0.log](/config/workspace/proto-socket/agent-task/m-high-performance-parallel-operations/03+01_payload_matrix/plan_cloud_G08_0.log:67)의 1KB/64KB/1MB 통합 검증 항목을 완료로 볼 수 없다.
+
+#### 해결 방법
+
+- `bash agent-ops/skills/project/run-proto-socket-test-matrix/scripts/run_stress.sh --full --profile payload`를 실행한다.
+- 실행 결과 파일에서 1MB rows 또는 required SKIP/BLOCKED 축을 확인한다.
+- 결과가 FAIL이면 실패 언어/transport/axis를 기준으로 최소 수정 후 같은 명령을 재실행한다.
+- 결과가 INCOMPLETE이면 stability 위반 0 여부와 required SKIP 사유를 명확히 기록한다.
+
+#### 테스트 작성
+
+- 새 테스트 파일 작성 없음. 기존 stress harness full profile 실행으로 검증한다.
+
+#### 중간 검증
+
+```bash
+bash agent-ops/skills/project/run-proto-socket-test-matrix/scripts/run_stress.sh --full --profile payload
+```
+
+기대: 1KB, 64KB, 1MB payload rows 또는 명시적 required SKIP/BLOCKED 축이 결과 파일에 기록되고, stability violations가 0이거나 실제 실패 원인이 코드 수정으로 해소된다.
+
+### [REVIEW_PAYLOAD_MATRIX-2] 리뷰 증거 기록 보강
+
+#### 문제
+
+[code_review_cloud_G08_0.log](/config/workspace/proto-socket/agent-task/m-high-performance-parallel-operations/03+01_payload_matrix/code_review_cloud_G08_0.log:66)는 검증 결과를 요약으로만 남겼다. review stub 계약은 실제 stdout/stderr 또는 검증 가능한 저장 evidence path를 요구한다.
+
+#### 해결 방법
+
+- `CODE_REVIEW-cloud-G08.md`의 검증 결과에 각 명령의 실제 stdout/stderr tail을 붙인다.
+- 출력이 긴 명령은 결과 기록 파일과 로그 경로를 함께 쓰고, 해당 파일에 포함된 핵심 row/SKIP/exit status를 발췌한다.
+- quick payload 기존 결과를 그대로 사용할 경우에도 실제 결과 파일 경로와 해당 row/SKIP 근거를 함께 기록한다.
+
+#### 테스트 작성
+
+- 문서 증거 보강 작업이다. 별도 테스트 파일 작성 없음.
+
+#### 중간 검증
+
+```bash
+rg --sort path "payload=1MB|overall_result|SKIPPED/BLOCKED|stability_violations" agent-test/runs
+```
+
+기대: 새 full payload 결과 파일에서 1MB row 또는 SKIP/BLOCKED 축과 전체 결과값을 확인할 수 있다.
+
+## 의존 관계 및 구현 순서
+
+1. `code_review_cloud_G08_0.log`의 Required 이슈를 읽는다.
+2. full payload matrix를 실행한다.
+3. 필요 시 최소 코드 수정 후 full payload를 재실행한다.
+4. TypeScript check/test, full matrix, `git diff --check`를 재확인한다.
+5. review stub에 실제 증거를 기록한다.
+
+## 수정 파일 요약
+
+| 파일 | 항목 |
+|---|---|
+| `CODE_REVIEW-cloud-G08.md` | REVIEW_PAYLOAD_MATRIX-1, REVIEW_PAYLOAD_MATRIX-2 |
+| payload harness files | full payload 실패가 코드 결함으로 확인된 경우에만 최소 수정 |
+
+## 최종 검증
+
+```bash
+bash agent-ops/skills/project/run-proto-socket-test-matrix/scripts/run_stress.sh --full --profile payload
+cd typescript && npm run check && npm test
+bash agent-ops/skills/project/run-proto-socket-test-matrix/scripts/run_matrix.sh --all
+git diff --check
+```
+
+기대: full payload 결과가 1MB evidence를 남기고, TypeScript check/test와 full matrix가 PASS하며, whitespace error가 없다. 모든 코드 변경과 증거 기록 완료 후 반드시 `CODE_REVIEW-cloud-G08.md`의 구현 에이전트 소유 섹션을 채운다.
--- a/agent-task/m-high-performance-parallel-operations/03+01_payload_matrix/CODE_REVIEW-cloud-G08.md
+++ b/agent-task/m-high-performance-parallel-operations/03+01_payload_matrix/CODE_REVIEW-cloud-G08.md
@ -1,38 +0,0 @@
-<!-- task=m-high-performance-parallel-operations/03+01_payload_matrix plan=0 tag=PAYLOAD_MATRIX -->
-
-# Code Review Reference - PAYLOAD_MATRIX
-
-> **[IMPLEMENTING AGENT - READ FIRST] Filling in this file is the mandatory final step of implementation.**
-
-## 구현 체크리스트
-
- [ ] `01_lang_baseline` 완료 근거를 확인한다.
- [ ] payload size matrix를 추가한다. 검증: 1KB, 64KB, 1MB payload에서 latency, throughput, memory peak, gateway backlog가 기록된다.
- [ ] quick mode는 작은 샘플, full mode는 Milestone 기준 payload matrix를 실행하도록 한다.
- [ ] payload별 결과 row가 공통 schema의 `Payload(bytes)`와 stability counters를 채운다.
- [ ] CODE_REVIEW-*-G??.md의 구현 에이전트 소유 섹션을 실제 구현 내용과 검증 출력으로 채운다. 이 항목이 완료되기 전에는 구현이 완료된 것이 아니다.
-
-## 구현 메모
-
- 변경 파일:
- 주요 결정:
- 계획 대비 변경:
-
-## 검증 결과
-
- 실행 명령:
- 결과 기록 파일:
- stdout/stderr 요약:
- 미실행 항목:
-
-## 사용자 리뷰 요청
-
-_기본값은 `없음`이다. 구현 중 사용자 결정, 사용자 소유 외부 환경/secret/서비스 준비, 또는 계획 범위 변경 없이는 안전하게 진행할 수 없으면 아래 항목을 실제 내용으로 교체하고, 구현을 중단한 뒤 active 파일을 그대로 둔 채 리뷰를 요청한다. 후속 에이전트가 명령 재실행이나 산출물 수집으로 해소할 수 있는 검증 증거 공백만으로는 사용자 리뷰 요청을 작성하지 않는다._
-
- 상태: 없음
- 사유 유형: 없음
- 결정 필요: 없음
- 차단 근거: 없음
- 실행한 검증/명령: 없음
- 자동 후속 불가 이유: 없음
- 재개 조건: 없음
--- a/dart/bench/stress.dart
+++ b/dart/bench/stress.dart
@ -18,7 +18,12 @@ import 'package:proto_socket/proto_socket.dart';
 const _host = '127.0.0.1';
 const _language = 'Dart';
 const _wsPath = '/';
-const _allProfiles = ['roundtrip', 'burst', 'sustained', 'parallel'];
+const _allProfiles = ['roundtrip', 'burst', 'sustained', 'parallel', 'payload'];
+
+// payload size matrix 축. quick은 작은 샘플(1KB/64KB), full은 Milestone 기준(1KB/64KB/1MB)을 측정한다.
+const _payloadSeed = '0123456789abcdef';
+const _payloadSizesQuick = [1024, 65536];
+const _payloadSizesFull = [1024, 65536, 1048576];

 // Dart의 heartbeat는 interval 0이 "비활성"이 아니라 "즉시 발화"다(Timer(0ms)). 다른 언어는 0으로
 // heartbeat를 끄지만 Dart에서 0,0을 쓰면 연결이 즉시 heartbeat를 보내고 wait timeout 후 스스로
@ -106,6 +111,20 @@ Future<int> _freePort() async {
 int _testDataPayloadBytes(String message) =>
    (TestData()..index = 0 ..message = message).writeToBuffer().length;

+/// size 바이트 길이의 deterministic filler string을 만든다.
+String _payloadFiller(int size) {
+  if (size <= 0) return '';
+  final reps = (size + _payloadSeed.length - 1) ~/ _payloadSeed.length;
+  return (_payloadSeed * reps).substring(0, size);
+}
+
+/// payload 크기를 사람이 읽는 축 이름으로 바꾼다(1024 -> 1KB, 1048576 -> 1MB).
+String _payloadLabel(int bytes) {
+  if (bytes >= 1048576 && bytes % 1048576 == 0) return '${bytes ~/ 1048576}MB';
+  if (bytes >= 1024 && bytes % 1024 == 0) return '${bytes ~/ 1024}KB';
+  return '${bytes}B';
+}
+
 double _percentile(List<double> sorted, double p) {
  if (sorted.isEmpty) return 0;
  var rank = ((p / 100.0) * sorted.length).ceil() - 1;
@ -478,11 +497,114 @@ Future<void> _profileParallel(String transport, String mode) async {
  _log('[parallel] transport=$transport done violations=${s.violations()}');
 }

+/// payload size matrix. 동일 connection request-response를 1KB/64KB/1MB payload에서 측정한다.
+/// message field를 deterministic filler로 채우고 실제 serialized payload bytes, payload별
+/// p50/p95/p99 latency, throughput, peak RSS, stability counters를 결과 row에 남긴다.
+Future<void> _profilePayload(String transport, String mode) async {
+  final sizes = mode == 'quick' ? _payloadSizesQuick : _payloadSizesFull;
+  final concurrency = mode == 'quick' ? 4 : 8;
+  final requests = mode == 'quick' ? 20 : 100;
+  final timeout = Duration(seconds: mode == 'quick' ? 10 : 30);
+  _log('[payload] transport=$transport mode=$mode '
+      'sizes=${sizes.map(_payloadLabel).toList()} concurrency=$concurrency requests/size=$requests');
+  for (final size in sizes) {
+    final s = _Stability();
+    final filler = _payloadFiller(size);
+    final expectedEcho = 'echo:$filler';
+    final payloadBytes = _testDataPayloadBytes(filler);
+    final axis = 'payload=${_payloadLabel(size)}';
+    var peak = _memMb();
+    final port = await _freePort();
+    final server = _makeEchoServer(transport, port);
+    await server.start();
+    try {
+      final handle = await _dialWithRetry(transport, port);
+      try {
+        final latencies = <double>[];
+        var issued = 0;
+        var nextIndex = 0;
+        final sw = Stopwatch()..start();
+        while (issued < requests) {
+          final batchSize =
+              concurrency < requests - issued ? concurrency : requests - issued;
+          final futures = <Future<void>>[];
+          for (var i = 0; i < batchSize; i++) {
+            final index = nextIndex++;
+            futures.add(() async {
+              final reqSw = Stopwatch()..start();
+              try {
+                final res = await handle.comm
+                    .sendRequest<TestData, TestData>(TestData()
+                      ..index = index
+                      ..message = filler)
+                    .timeout(timeout);
+                latencies.add(reqSw.elapsedMicroseconds / 1000.0);
+                if (res.index != index * 2 || res.message != expectedEcho) {
+                  s.nonceMismatch += 1;
+                }
+              } catch (error) {
+                _classifyRequestError(error.toString(), s);
+              }
+            }());
+          }
+          issued += batchSize;
+          await Future.wait(futures);
+          final cur = _memMb();
+          if (cur > peak) peak = cur;
+        }
+        final elapsedMs = sw.elapsedMicroseconds / 1000.0;
+        final sorted = List<double>.from(latencies)..sort();
+        final throughput =
+            elapsedMs > 0 ? latencies.length / elapsedMs * 1000.0 : 0.0;
+        _emitRow(
+          profile: 'payload',
+          axis: axis,
+          transport: transport,
+          payloadBytes: payloadBytes,
+          clientCount: 1,
+          requests: latencies.length,
+          throughput: throughput,
+          p50: _percentile(sorted, 50),
+          p95: _percentile(sorted, 95),
+          p99: _percentile(sorted, 99),
+          mem: peak,
+          s: s,
+        );
+      } finally {
+        await handle.close();
+        if (handle.comm.isAlive) s.pendingLeak += 1;
+      }
+    } catch (error) {
+      s.timeouts += 1;
+      _log('[payload] size=${_payloadLabel(size)} error=$error');
+      _emitRow(
+        profile: 'payload',
+        axis: axis,
+        transport: transport,
+        payloadBytes: payloadBytes,
+        clientCount: 1,
+        requests: 0,
+        throughput: 0,
+        p50: 0,
+        p95: 0,
+        p99: 0,
+        mem: peak,
+        s: s,
+      );
+    } finally {
+      await server.stop();
+    }
+    _log('[payload] transport=$transport size=${_payloadLabel(size)} bytes=$payloadBytes '
+        'peakMemMb=${peak.toStringAsFixed(1)} violations=${s.violations()}');
+  }
+}
+
 final _runners = <String, Future<void> Function(String, String)>{
  'roundtrip': _profileRoundtrip,
  'burst': _profileBurst,
  'sustained': _profileSustained,
  'parallel': _profileParallel,
+  'payload': _profilePayload,
 };

 List<String> _parseList(List<String> args, String prefix, List<String> def) {
--- a/go/bench/stress.go
+++ b/go/bench/stress.go
@ -38,7 +38,15 @@ const (
 	transWS  = "ws"
 )

-var allProfiles = []string{"roundtrip", "burst", "sustained", "parallel"}
+var allProfiles = []string{"roundtrip", "burst", "sustained", "parallel", "payload"}
+
+// payload size matrix 축. quick은 작은 샘플(1KB/64KB), full은 Milestone 기준(1KB/64KB/1MB)을 측정한다.
+const payloadSeed = "0123456789abcdef"
+
+var (
+	payloadSizesQuick = []int{1024, 65536}
+	payloadSizesFull  = []int{1024, 65536, 1048576}
+)

 // stability는 안정성 위반 카운터다. 0이 아니면 해당 row는 FAIL이고 프로세스도 non-zero exit한다.
 type stability struct {
@ -107,6 +115,31 @@ func testDataPayloadBytes(message string) int {
 	return len(b)
 }

+// payloadFiller는 size 바이트 길이의 deterministic filler string을 만든다.
+func payloadFiller(size int) string {
+	if size <= 0 {
+		return ""
+	}
+	var b strings.Builder
+	b.Grow(size + len(payloadSeed))
+	for b.Len() < size {
+		b.WriteString(payloadSeed)
+	}
+	return b.String()[:size]
+}
+
+// payloadLabel은 payload 크기를 사람이 읽는 축 이름으로 바꾼다(1024 -> 1KB, 1048576 -> 1MB).
+func payloadLabel(bytes int) string {
+	switch {
+	case bytes >= 1048576 && bytes%1048576 == 0:
+		return fmt.Sprintf("%dMB", bytes/1048576)
+	case bytes >= 1024 && bytes%1024 == 0:
+		return fmt.Sprintf("%dKB", bytes/1024)
+	default:
+		return fmt.Sprintf("%dB", bytes)
+	}
+}
+
 func percentile(sorted []float64, p float64) float64 {
 	if len(sorted) == 0 {
 		return 0
@ -582,6 +615,132 @@ func profileParallel(transport string, mode string) {
 	logf("[parallel] transport=%s done violations=%d", transport, s.violations())
 }

+// profilePayload는 payload size matrix를 측정한다. 동일 connection request-response를 1KB/64KB/1MB
+// payload에서 돌리고, message field를 deterministic filler로 채워 실제 serialized payload bytes,
+// payload별 p50/p95/p99 latency, throughput, peak heap, stability counters를 결과 row에 남긴다.
+func profilePayload(transport string, mode string) {
+	sizes := payloadSizesQuick
+	concurrency := 4
+	requests := 20
+	timeout := 10 * time.Second
+	if mode == "full" {
+		sizes = payloadSizesFull
+		concurrency = 8
+		requests = 100
+		timeout = 30 * time.Second
+	}
+	labels := make([]string, len(sizes))
+	for i, sz := range sizes {
+		labels[i] = payloadLabel(sz)
+	}
+	logf("[payload] transport=%s mode=%s sizes=%s concurrency=%d requests/size=%d",
+		transport, mode, strings.Join(labels, ","), concurrency, requests)
+
+	for _, size := range sizes {
+		s := &stability{}
+		filler := payloadFiller(size)
+		expectedEcho := "echo:" + filler
+		payloadBytes := testDataPayloadBytes(filler)
+		axis := "payload=" + payloadLabel(size)
+		// Go WsClient/WsServer는 nhooyr 기본 read limit(32KiB)을 그대로 쓰므로 ~32KB를 넘는 WS frame은
+		// read cap을 초과해 끊긴다. WS read limit을 올리는 것은 optimize Epic의 transport 변경이라 여기서는
+		// 측정 가능한 TCP와 작은 WS payload만 기록하고 큰 WS payload는 deferred로 남긴다.
+		if transport == transWS && payloadBytes >= 32768 {
+			emitSkip("payload", axis, transport,
+				"deferred: optimize Epic — Go WsClient/WsServer keep the nhooyr default 32KiB read limit, so WS payloads above ~32KB exceed the frame read cap")
+			logf("[payload] transport=%s size=%s bytes=%d deferred (WS 32KiB read limit)", transport, payloadLabel(size), payloadBytes)
+			continue
+		}
+		peak := memMb()
+		ctx, cancel := context.WithCancel(context.Background())
+		srv, err := startRequestServer(ctx, transport, s)
+		if err != nil {
+			cancel()
+			s.timeouts.Add(1)
+			logf("[payload] size=%s server error=%v", payloadLabel(size), err)
+			emitRow(rowInput{profile: "payload", axis: axis, transport: transport, payloadBytes: payloadBytes, clientCount: 1, memMb: peak, stab: s})
+			continue
+		}
+		h, err := dialWithRetry(transport, srv.port)
+		if err != nil {
+			s.timeouts.Add(1)
+			logf("[payload] size=%s dial error=%v", payloadLabel(size), err)
+			emitRow(rowInput{profile: "payload", axis: axis, transport: transport, payloadBytes: payloadBytes, clientCount: 1, memMb: peak, stab: s})
+			srv.stop()
+			cancel()
+			continue
+		}
+		var mu sync.Mutex
+		latencies := make([]float64, 0, requests)
+		issued := 0
+		nextIndex := int32(0)
+		started := time.Now()
+		for issued < requests {
+			batchSize := concurrency
+			if requests-issued < batchSize {
+				batchSize = requests - issued
+			}
+			var wg sync.WaitGroup
+			for i := 0; i < batchSize; i++ {
+				idx := nextIndex
+				nextIndex++
+				wg.Add(1)
+				go func(index int32) {
+					defer wg.Done()
+					reqStart := time.Now()
+					res, err := toki.SendRequestTyped[*packets.TestData, *packets.TestData](
+						h.comm, &packets.TestData{Index: index, Message: filler}, timeout)
+					if err != nil {
+						classifyRequestError(err, s)
+						return
+					}
+					elapsed := float64(time.Since(reqStart).Microseconds()) / 1000.0
+					mu.Lock()
+					latencies = append(latencies, elapsed)
+					mu.Unlock()
+					if res.GetIndex() != index*2 || res.GetMessage() != expectedEcho {
+						s.nonceMismatch.Add(1)
+					}
+				}(idx)
+			}
+			issued += batchSize
+			wg.Wait()
+			if cur := memMb(); cur > peak {
+				peak = cur
+			}
+		}
+		elapsedMs := float64(time.Since(started).Microseconds()) / 1000.0
+		sorted := append([]float64(nil), latencies...)
+		sort.Float64s(sorted)
+		throughput := 0.0
+		if elapsedMs > 0 {
+			throughput = float64(len(latencies)) / elapsedMs * 1000.0
+		}
+		emitRow(rowInput{
+			profile:      "payload",
+			axis:         axis,
+			transport:    transport,
+			payloadBytes: payloadBytes,
+			clientCount:  1,
+			requests:     len(latencies),
+			throughput:   throughput,
+			p50:          percentile(sorted, 50),
+			p95:          percentile(sorted, 95),
+			p99:          percentile(sorted, 99),
+			memMb:        peak,
+			stab:         s,
+		})
+		_ = h.close()
+		if h.comm.IsAlive() {
+			s.pendingLeak.Add(1)
+		}
+		srv.stop()
+		cancel()
+		logf("[payload] transport=%s size=%s bytes=%d peakMemMb=%.1f violations=%d",
+			transport, payloadLabel(size), payloadBytes, peak, s.violations())
+	}
+}
+
 // mustPort는 burst 헬퍼에서 free port 확보 실패를 panic이 아니라 0으로 떨어뜨려 server start가 BLOCKED를 유도하게 한다.
 func mustPort() int {
 	p, err := freePort()
@ -634,6 +793,7 @@ func main() {
 		"burst":     profileBurst,
 		"sustained": profileSustained,
 		"parallel":  profileParallel,
+		"payload":   profilePayload,
 	}

 	for _, transport := range transports {
--- a/kotlin/crosstest/stress.kt
+++ b/kotlin/crosstest/stress.kt
@ -41,7 +41,12 @@ import kotlin.system.exitProcess
 private const val HOST = "127.0.0.1"
 private const val LANGUAGE = "Kotlin"
 private const val WS_PATH = "/"
-private val ALL_PROFILES = listOf("roundtrip", "burst", "sustained", "parallel")
+private val ALL_PROFILES = listOf("roundtrip", "burst", "sustained", "parallel", "payload")
+
+// payload size matrix 축. quick은 작은 샘플(1KB/64KB), full은 Milestone 기준(1KB/64KB/1MB)을 측정한다.
+private const val PAYLOAD_SEED = "0123456789abcdef"
+private val PAYLOAD_SIZES_QUICK = listOf(1024, 65536)
+private val PAYLOAD_SIZES_FULL = listOf(1024, 65536, 1048576)

 private val rowsEmitted = AtomicInteger(0)
 private val totalViolations = AtomicLong(0)
@ -76,6 +81,20 @@ private fun freePort(): Int = ServerSocket(0, 50, InetAddress.getByName(HOST)).u
 private fun testDataPayloadBytes(message: String): Int =
    TestData.newBuilder().setIndex(0).setMessage(message).build().toByteArray().size

+// payloadFiller는 size 바이트 길이의 deterministic filler string을 만든다.
+private fun payloadFiller(size: Int): String {
+    if (size <= 0) return ""
+    val reps = (size + PAYLOAD_SEED.length - 1) / PAYLOAD_SEED.length
+    return PAYLOAD_SEED.repeat(reps).substring(0, size)
+}
+
+// payloadLabel은 payload 크기를 사람이 읽는 축 이름으로 바꾼다(1024 -> 1KB, 1048576 -> 1MB).
+private fun payloadLabel(bytes: Int): String = when {
+    bytes >= 1048576 && bytes % 1048576 == 0 -> "${bytes / 1048576}MB"
+    bytes >= 1024 && bytes % 1024 == 0 -> "${bytes / 1024}KB"
+    else -> "${bytes}B"
+}
+
 private fun percentile(sorted: List<Double>, p: Double): Double {
    if (sorted.isEmpty()) return 0.0
    var rank = Math.ceil(p / 100.0 * sorted.size).toInt() - 1
@ -264,6 +283,29 @@ private suspend fun sendOne(comm: Communicator, index: Int, prefix: String, time
    }
 }

+private suspend fun sendPayloadOne(
+    comm: Communicator,
+    index: Int,
+    filler: String,
+    expectedEcho: String,
+    timeoutMs: Long,
+    latencies: ConcurrentLinkedQueue<Double>,
+    s: StressStability,
+) {
+    val started = System.nanoTime()
+    try {
+        val res: TestData = com.tokilabs.proto_socket.sendRequestTyped(
+            comm, TestData.newBuilder().setIndex(index).setMessage(filler).build(), timeoutMs,
+        )
+        latencies.add((System.nanoTime() - started) / 1e6)
+        if (res.index != index * 2 || res.message != expectedEcho) {
+            s.nonceMismatch.incrementAndGet()
+        }
+    } catch (error: Throwable) {
+        classifyRequestError(error, s)
+    }
+}
+
 private suspend fun runRequestLoad(comm: Communicator, total: Int, concurrency: Int, timeoutMs: Long, s: StressStability): List<Double> {
    val latencies = ConcurrentLinkedQueue<Double>()
    var issued = 0
@ -453,6 +495,71 @@ private suspend fun profileParallel(transport: String, mode: String) {
    log("[parallel] transport=$transport done violations=${s.violations()}")
 }

+// profilePayload는 payload size matrix를 측정한다. 동일 connection request-response를 1KB/64KB/1MB
+// payload에서 돌리고, message field를 deterministic filler로 채워 실제 serialized payload bytes,
+// payload별 p50/p95/p99 latency, throughput, used heap, stability counters를 결과 row에 남긴다.
+private suspend fun profilePayload(transport: String, mode: String) {
+    val sizes = if (mode == "quick") PAYLOAD_SIZES_QUICK else PAYLOAD_SIZES_FULL
+    val concurrency = if (mode == "quick") 4 else 8
+    val requests = if (mode == "quick") 20 else 100
+    val timeoutMs = if (mode == "quick") 10_000L else 30_000L
+    log("[payload] transport=$transport mode=$mode sizes=${sizes.map(::payloadLabel)} concurrency=$concurrency requests/size=$requests")
+    val deferred = deferredBottleneck(transport, "payload", concurrency)
+    if (deferred != null) {
+        for (size in sizes) emitSkip("payload", "payload=${payloadLabel(size)}", transport, deferred)
+        return
+    }
+    for (size in sizes) {
+        val s = StressStability()
+        val filler = payloadFiller(size)
+        val expectedEcho = "echo:$filler"
+        val payloadBytes = testDataPayloadBytes(filler)
+        val axis = "payload=${payloadLabel(size)}"
+        var peak = memMb()
+        val srv = startEchoServer(transport, freePort())
+        try {
+            val handle = dialWithRetry(transport, srv.port)
+            try {
+                val latencies = ConcurrentLinkedQueue<Double>()
+                var issued = 0
+                var nextIndex = 0
+                val started = System.nanoTime()
+                while (issued < requests) {
+                    val batchSize = minOf(concurrency, requests - issued)
+                    coroutineScope {
+                        for (i in 0 until batchSize) {
+                            val index = nextIndex++
+                            launch(Dispatchers.Default) {
+                                sendPayloadOne(handle.comm, index, filler, expectedEcho, timeoutMs, latencies, s)
+                            }
+                        }
+                    }
+                    issued += batchSize
+                    val cur = memMb()
+                    if (cur > peak) peak = cur
+                }
+                val elapsedMs = (System.nanoTime() - started) / 1e6
+                val sorted = latencies.toList().sorted()
+                val throughput = if (elapsedMs > 0) latencies.size / elapsedMs * 1000.0 else 0.0
+                emitRow(
+                    "payload", axis, transport, payloadBytes, 1, latencies.size, throughput,
+                    percentile(sorted, 50.0), percentile(sorted, 95.0), percentile(sorted, 99.0), peak, s,
+                )
+            } finally {
+                handle.close()
+                if (handle.comm.isAlive()) s.pendingLeak.incrementAndGet()
+            }
+        } catch (error: Throwable) {
+            s.timeouts.incrementAndGet()
+            log("[payload] size=${payloadLabel(size)} error=$error")
+            emitRow("payload", axis, transport, payloadBytes, 1, 0, 0.0, 0.0, 0.0, 0.0, peak, s)
+        } finally {
+            srv.stop()
+        }
+        log("[payload] transport=$transport size=${payloadLabel(size)} bytes=$payloadBytes peakMemMb=${String.format("%.1f", peak)} violations=${s.violations()}")
+    }
+}
+
 private fun parseList(args: Array<String>, prefix: String, def: List<String>): List<String> {
    for (arg in args) {
        if (arg.startsWith(prefix)) {
@ -484,6 +591,7 @@ fun main(args: Array<String>) = runBlocking {
        "burst" to ::profileBurst,
        "sustained" to ::profileSustained,
        "parallel" to ::profileParallel,
+        "payload" to ::profilePayload,
    )

    for (transport in transports) {
--- a/python/bench/stress.py
+++ b/python/bench/stress.py
@ -31,7 +31,12 @@ from proto_socket.ws_server import WsServer
 HOST = "127.0.0.1"
 LANGUAGE = "Python"
 WS_PATH = "/"
-ALL_PROFILES = ["roundtrip", "burst", "sustained", "parallel"]
+ALL_PROFILES = ["roundtrip", "burst", "sustained", "parallel", "payload"]
+
+# payload size matrix 축. quick은 작은 샘플(1KB/64KB), full은 Milestone 기준(1KB/64KB/1MB)을 측정한다.
+PAYLOAD_SEED = "0123456789abcdef"
+PAYLOAD_SIZES_QUICK = [1024, 65536]
+PAYLOAD_SIZES_FULL = [1024, 65536, 1048576]

 _rows_emitted = 0
 _total_violations = 0
@ -91,6 +96,23 @@ def test_data_payload_bytes(message: str) -> int:
    return len(TestData(index=0, message=message).SerializeToString())


+def payload_filler(size: int) -> str:
+    """size 바이트 길이의 deterministic filler string을 만든다."""
+    if size <= 0:
+        return ""
+    reps = -(-size // len(PAYLOAD_SEED))
+    return (PAYLOAD_SEED * reps)[:size]
+
+
+def payload_label(num_bytes: int) -> str:
+    """payload 크기를 사람이 읽는 축 이름으로 바꾼다(1024 -> 1KB, 1048576 -> 1MB)."""
+    if num_bytes >= 1048576 and num_bytes % 1048576 == 0:
+        return f"{num_bytes // 1048576}MB"
+    if num_bytes >= 1024 and num_bytes % 1024 == 0:
+        return f"{num_bytes // 1024}KB"
+    return f"{num_bytes}B"
+
+
 def percentile(sorted_values: list[float], p: float) -> float:
    if not sorted_values:
        return 0.0
@ -460,11 +482,107 @@ async def profile_parallel(transport: str, mode: str) -> None:
    log(f"[parallel] transport={transport} done violations={stability.violations()}")


+async def profile_payload(transport: str, mode: str) -> None:
+    sizes = PAYLOAD_SIZES_QUICK if mode == "quick" else PAYLOAD_SIZES_FULL
+    concurrency = 4 if mode == "quick" else 8
+    requests = 20 if mode == "quick" else 100
+    timeout = 10.0 if mode == "quick" else 30.0
+    log(
+        f"[payload] transport={transport} mode={mode} sizes={[payload_label(s) for s in sizes]} "
+        f"concurrency={concurrency} requests/size={requests}"
+    )
+    for size in sizes:
+        stability = Stability()
+        filler = payload_filler(size)
+        expected_echo = "echo:" + filler
+        payload_bytes = test_data_payload_bytes(filler)
+        axis = f"payload={payload_label(size)}"
+        peak = mem_mb()
+        port = free_port()
+        server = make_echo_server(transport, port)
+        await server.start()
+        try:
+            client = await dial_with_retry(transport, port)
+            try:
+                latencies: list[float] = []
+                issued = 0
+                next_index = 0
+                started = time.perf_counter()
+
+                async def one(index: int) -> None:
+                    req_start = time.perf_counter()
+                    try:
+                        res = await client.communicator.send_request(
+                            TestData(index=index, message=filler), TestData, timeout=timeout
+                        )
+                        latencies.append((time.perf_counter() - req_start) * 1000.0)
+                        if res.index != index * 2 or res.message != expected_echo:
+                            stability.nonce_mismatch += 1
+                    except Exception as exc:  # noqa: BLE001
+                        classify_request_error(str(exc), stability)
+
+                while issued < requests:
+                    batch_size = min(concurrency, requests - issued)
+                    indices = list(range(next_index, next_index + batch_size))
+                    next_index += batch_size
+                    issued += batch_size
+                    await asyncio.gather(*(one(i) for i in indices))
+                    current = mem_mb()
+                    if current > peak:
+                        peak = current
+                elapsed = (time.perf_counter() - started) * 1000.0
+                ordered = sorted(latencies)
+                throughput = (len(latencies) / elapsed * 1000.0) if elapsed > 0 else 0.0
+                emit_row(
+                    profile="payload",
+                    axis=axis,
+                    transport=transport,
+                    payload_bytes=payload_bytes,
+                    client_count=1,
+                    requests=len(latencies),
+                    throughput=throughput,
+                    p50=percentile(ordered, 50),
+                    p95=percentile(ordered, 95),
+                    p99=percentile(ordered, 99),
+                    mem=peak,
+                    stability=stability,
+                )
+            finally:
+                with suppress(Exception):
+                    await asyncio.wait_for(client.close(), 2.0)
+                if client.communicator.is_alive():
+                    stability.pending_leak += 1
+        except Exception as exc:  # noqa: BLE001
+            stability.timeouts += 1
+            log(f"[payload] size={payload_label(size)} error={exc}")
+            emit_row(
+                profile="payload",
+                axis=axis,
+                transport=transport,
+                payload_bytes=payload_bytes,
+                client_count=1,
+                requests=0,
+                throughput=0.0,
+                p50=0.0,
+                p95=0.0,
+                p99=0.0,
+                mem=peak,
+                stability=stability,
+            )
+        finally:
+            await server.stop()
+        log(
+            f"[payload] transport={transport} size={payload_label(size)} bytes={payload_bytes} "
+            f"peakMemMb={peak:.1f} violations={stability.violations()}"
+        )
+
+
 RUNNERS = {
    "roundtrip": profile_roundtrip,
    "burst": profile_burst,
    "sustained": profile_sustained,
    "parallel": profile_parallel,
+    "payload": profile_payload,
 }


--- a/python/proto_socket/ws_client.py
+++ b/python/proto_socket/ws_client.py
@ -16,6 +16,7 @@ except ImportError:  # websockets 12.x legacy API
 from proto_socket.base_client import BaseClient
 from proto_socket.communicator import ParserMap, type_name_of
 from proto_socket.packets.message_common_pb2 import HeartBeat, PacketBase
+from proto_socket.tcp_client import MAX_PACKET_SIZE


 class WsClient(BaseClient):
@ -77,7 +78,7 @@ async def connect_ws(
    parser_map: ParserMap,
 ) -> WsClient:
    uri = f"ws://{host}:{port}{path}"
-    ws = await ws_connect(uri)
+    ws = await ws_connect(uri, max_size=MAX_PACKET_SIZE)
    return WsClient(ws, interval_sec, wait_sec, parser_map)


@ -91,5 +92,5 @@ async def connect_wss(
    parser_map: ParserMap,
 ) -> WsClient:
    uri = f"wss://{host}:{port}{path}"
-    ws = await ws_connect(uri, ssl=ssl_context)
+    ws = await ws_connect(uri, ssl=ssl_context, max_size=MAX_PACKET_SIZE)
    return WsClient(ws, interval_sec, wait_sec, parser_map)
--- a/python/proto_socket/ws_server.py
+++ b/python/proto_socket/ws_server.py
@ -17,6 +17,7 @@ except ImportError:  # websockets 12.x legacy API
    _NEW_WEBSOCKETS_API = False

 from proto_socket.communicator import ParserMap
+from proto_socket.tcp_client import MAX_PACKET_SIZE
 from proto_socket.ws_client import WsClient


@ -55,7 +56,13 @@ class WsServer:

    async def start(self) -> None:
        handler = self._handle_websocket if _NEW_WEBSOCKETS_API else self._handle_legacy_websocket
-        self._server = await ws_serve(handler, self._host, self._port, ssl=self._ssl_context)
+        self._server = await ws_serve(
+            handler,
+            self._host,
+            self._port,
+            ssl=self._ssl_context,
+            max_size=MAX_PACKET_SIZE,
+        )

    async def stop(self) -> None:
        if self._server is not None:
--- a/python/test/test_ws.py
+++ b/python/test/test_ws.py
@ -67,6 +67,34 @@ async def test_ws_send_receive():
    await server.stop()


+@pytest.mark.asyncio
+async def test_ws_large_payload_request_response():
+    server = WsServer(
+        "127.0.0.1",
+        0,
+        "/",
+        lambda ws: WsClient(ws, 0, 0, parser_map()),
+    )
+    server.on_client_connected = lambda client: client.communicator.add_request_listener(
+        type_name_of(ProtoTestData),
+        lambda req: ProtoTestData(index=req.index * 2, message="echo:" + req.message),
+    )
+    await server.start()
+    client = await connect_ws("127.0.0.1", server.port, "/", 0, 0, parser_map())
+    payload = "0123456789abcdef" * 65536
+    try:
+        result = await client.communicator.send_request(
+            ProtoTestData(index=7, message=payload),
+            ProtoTestData,
+            timeout=10,
+        )
+        assert result.index == 14
+        assert result.message == "echo:" + payload
+    finally:
+        await client.close()
+        await server.stop()
+
+
@pytest.mark.asyncio
 async def test_ws_server_push():
    pushed = asyncio.get_running_loop().create_future()
--- a/typescript/bench/stress.ts
+++ b/typescript/bench/stress.ts
@ -50,13 +50,19 @@ function newTcpClient(socket: net.Socket): TcpClient {

 const HOST = "127.0.0.1";
 const WS_PATH = "/";
-const ALL_PROFILES = ["roundtrip", "burst", "sustained", "parallel", "gateway"] as const;
+const ALL_PROFILES = ["roundtrip", "burst", "sustained", "parallel", "payload", "gateway"] as const;
 type Profile = (typeof ALL_PROFILES)[number];
 type Mode = "quick" | "full";
 /** same-language transport baseline 축. gateway profile은 transport-agnostic frame-ingest 경로라 별도다. */
 const ALL_TRANSPORTS = ["tcp", "ws"] as const;
 type WireTransport = (typeof ALL_TRANSPORTS)[number];
-const TRANSPORT_PROFILES: ReadonlySet<Profile> = new Set(["roundtrip", "burst", "sustained", "parallel"]);
+const TRANSPORT_PROFILES: ReadonlySet<Profile> = new Set(["roundtrip", "burst", "sustained", "parallel", "payload"]);
+
+/** payload size matrix 축. quick은 작은 샘플(1KB/64KB), full은 Milestone 기준(1KB/64KB/1MB)을 측정한다. */
+const PAYLOAD_SIZES_QUICK = [1_024, 65_536] as const;
+const PAYLOAD_SIZES_FULL = [1_024, 65_536, 1_048_576] as const;
+/** deterministic filler seed. message field를 이 16자 패턴으로 채워 재현 가능한 payload를 만든다. */
+const PAYLOAD_SEED = "0123456789abcdef";

 /** 안정성 위반 카운터. 0이 아니면 해당 축은 FAIL이고 프로세스도 non-zero exit한다. */
 interface Stability {
@ -182,6 +188,25 @@ function testDataPayloadBytes(message: string): number {
  return toBinary(TestDataSchema, create(TestDataSchema, { index: 0, message })).byteLength;
 }

+/** size 바이트 길이의 deterministic filler string을 만든다. payload matrix의 message field를 채운다. */
+function payloadFiller(size: number): string {
+  if (size <= 0) {
+    return "";
+  }
+  return PAYLOAD_SEED.repeat(Math.ceil(size / PAYLOAD_SEED.length)).slice(0, size);
+}
+
+/** payload 크기를 사람이 읽는 축 이름으로 바꾼다(1024 -> 1KB, 1048576 -> 1MB). */
+function payloadLabel(bytes: number): string {
+  if (bytes >= 1_048_576 && bytes % 1_048_576 === 0) {
+    return `${bytes / 1_048_576}MB`;
+  }
+  if (bytes >= 1_024 && bytes % 1_024 === 0) {
+    return `${bytes / 1_024}KB`;
+  }
+  return `${bytes}B`;
+}
+
 function sleep(ms: number): Promise<void> {
  return new Promise((resolve) => setTimeout(resolve, ms));
 }
@ -555,6 +580,82 @@ async function profileParallel(transport: WireTransport, mode: Mode): Promise<vo
  log(`[parallel] transport=${transport} done violations=${stabilityViolations(stability)}`);
 }

+/**
+ * payload size matrix. 동일 connection request-response를 1KB/64KB/1MB payload에서 측정한다.
+ * message field를 deterministic filler로 채우고 실제 serialized payload bytes를 기록하며, payload별
+ * p50/p95/p99 latency, throughput, peak memory, stability counters를 결과 row에 남긴다.
+ */
+async function profilePayload(transport: WireTransport, mode: Mode): Promise<void> {
+  const sizes = mode === "quick" ? PAYLOAD_SIZES_QUICK : PAYLOAD_SIZES_FULL;
+  const concurrency = mode === "quick" ? 4 : 8;
+  const requests = mode === "quick" ? 20 : 100;
+  const timeoutMs = mode === "quick" ? 10_000 : 30_000;
+  log(
+    `[payload] transport=${transport} mode=${mode} sizes=${sizes.map(payloadLabel).join(",")} ` +
+      `concurrency=${concurrency} requests/size=${requests}`,
+  );
+
+  for (const size of sizes) {
+    const stability = newStability();
+    const filler = payloadFiller(size);
+    const expectedEcho = `echo:${filler}`;
+    const payloadBytes = testDataPayloadBytes(filler);
+    let peakMem = memMb();
+    await withRequestServer(transport, stability, async (port) => {
+      const client = await connectClient(transport, port);
+      try {
+        const latencies: number[] = [];
+        let issued = 0;
+        let nextIndex = 0;
+        const started = performance.now();
+        while (issued < requests) {
+          const batchSize = Math.min(concurrency, requests - issued);
+          const batch: Array<Promise<void>> = [];
+          for (let i = 0; i < batchSize; i += 1) {
+            const index = nextIndex;
+            nextIndex += 1;
+            const reqStart = performance.now();
+            batch.push(
+              client.communicator
+                .sendRequest(create(TestDataSchema, { index, message: filler }), TestDataSchema, timeoutMs)
+                .then((res) => {
+                  latencies.push(performance.now() - reqStart);
+                  if (res.index !== index * 2 || res.message !== expectedEcho) {
+                    stability.nonceMismatch += 1;
+                  }
+                })
+                .catch((err: unknown) => {
+                  classifyRequestError(errorMessage(err), stability);
+                }),
+            );
+          }
+          issued += batchSize;
+          await Promise.all(batch);
+          const current = memMb();
+          if (current > peakMem) {
+            peakMem = current;
+          }
+        }
+        const elapsed = performance.now() - started;
+        summarizeLatencies("payload", `payload=${payloadLabel(size)}`, latencies, elapsed, stability, "off", peakMem, {
+          transport: transportName(transport),
+          payloadBytes,
+          clientCount: 1,
+        });
+      } finally {
+        await client.close();
+        if (!leakClear(client)) {
+          stability.pendingLeak += 1;
+        }
+      }
+    });
+    log(
+      `[payload] transport=${transport} size=${payloadLabel(size)} bytes=${payloadBytes} ` +
+        `peakMemMb=${peakMem.toFixed(1)} violations=${stabilityViolations(stability)}`,
+    );
+  }
+}
+
 const NOOP_TRANSPORT: Transport = {
  writePacket: async () => {},
  close: async () => {},
@ -722,6 +823,7 @@ async function main(): Promise<void> {
    burst: profileBurst,
    sustained: profileSustained,
    parallel: profileParallel,
+    payload: profilePayload,
  };

  // transport별 same-language 축은 transport를 바깥 루프로 돈다. gateway는 transport-agnostic in-process