diff --git a/.gitignore b/.gitignore
index 47aa6c0..002afd2 100644
--- a/.gitignore
+++ b/.gitignore
@@ -14,5 +14,6 @@ loadtest/pion-client/results/
 loadtest/pion-client/.gocache/
 loadtest/pion-client/*.exe
 loadtest/server-results/
+loadtest/results/
 loadtest/videos/*
 !loadtest/videos/README.md
diff --git a/loadtest/scripts/analyze_bypass_runs.py b/loadtest/scripts/analyze_bypass_runs.py
new file mode 100644
index 0000000..839859c
--- /dev/null
+++ b/loadtest/scripts/analyze_bypass_runs.py
@@ -0,0 +1,504 @@
+#!/usr/bin/env python3
+"""Aggregate repeated Pion bypass runs with matching Windows server metrics."""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import hashlib
+import json
+import math
+import re
+import statistics
+from collections import defaultdict
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Any, Iterable
+
+
+RUN_RE = re.compile(
+    r"^bypass-(?P<clients>1|2|4|8)-clients-5m-cycle(?P<cycle>[123])\.json$"
+)
+CONNECTED_RE = re.compile(
+    r"^(?P<time>\d{4}/\d{2}/\d{2} \d{2}:\d{2}:\d{2}) "
+    r"client=\d+ session=\S+ connected$"
+)
+KST = timezone(timedelta(hours=9))
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--client-dir", type=Path, required=True)
+    parser.add_argument("--server-dir", type=Path, required=True)
+    parser.add_argument("--output", type=Path)
+    parser.add_argument("--manifest-output", type=Path)
+    return parser.parse_args()
+
+
+def parse_time(value: str) -> datetime:
+    return datetime.fromisoformat(value)
+
+
+def percentile(values: Iterable[float], percentile_value: float) -> float:
+    ordered = sorted(values)
+    if not ordered:
+        raise ValueError("cannot calculate a percentile from no values")
+    position = (len(ordered) - 1) * percentile_value
+    lower = math.floor(position)
+    upper = math.ceil(position)
+    if lower == upper:
+        return ordered[lower]
+    fraction = position - lower
+    return ordered[lower] * (1 - fraction) + ordered[upper] * fraction
+
+
+def population_stddev(values: Iterable[float]) -> float:
+    materialized = list(values)
+    return statistics.pstdev(materialized) if len(materialized) > 1 else 0.0
+
+
+def mean(values: Iterable[float]) -> float:
+    return statistics.fmean(values)
+
+
+def sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as source:
+        for block in iter(lambda: source.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest().upper()
+
+
+def last_connected_at(log_path: Path, target_clients: int) -> datetime:
+    connected: list[datetime] = []
+    for line in log_path.read_text(encoding="utf-8").splitlines():
+        match = CONNECTED_RE.match(line.strip())
+        if match:
+            connected.append(
+                datetime.strptime(match.group("time"), "%Y/%m/%d %H:%M:%S").replace(
+                    tzinfo=KST
+                )
+            )
+    if len(connected) != target_clients:
+        raise ValueError(
+            f"{log_path.name}: expected {target_clients} connection lines, "
+            f"found {len(connected)}"
+        )
+    return max(connected)
+
+
+def load_csv(path: Path) -> list[dict[str, Any]]:
+    with path.open(encoding="utf-8-sig", newline="") as source:
+        return list(csv.DictReader(source))
+
+
+def preceding_sample(
+    samples: list[dict[str, Any]], boundary: datetime
+) -> dict[str, Any]:
+    preceding = [sample for sample in samples if sample["_timestamp"] <= boundary]
+    return max(preceding or samples, key=lambda sample: sample["_timestamp"])
+
+
+def analyze_client(
+    samples: list[dict[str, Any]], stable_start: datetime, stable_end: datetime
+) -> dict[str, Any]:
+    ordered = sorted(samples, key=lambda sample: sample["_timestamp"])
+    stable = [
+        sample
+        for sample in ordered
+        if stable_start <= sample["_timestamp"] <= stable_end
+    ]
+    if not stable:
+        raise ValueError("no client samples in stable window")
+
+    before = preceding_sample(ordered, stable_start)
+    after = max(stable, key=lambda sample: sample["_timestamp"])
+    sent_delta = int(after["sent_frames"]) - int(before["sent_frames"])
+    received_delta = int(after["received_frames"]) - int(before["received_frames"])
+    packet_delta = int(after["received_packets"]) - int(before["received_packets"])
+    lost_delta = int(after["lost_packets"]) - int(before["lost_packets"])
+    receive_rates = [float(sample["receive_fps"]) for sample in stable]
+    send_rates = [float(sample["send_fps"]) for sample in stable]
+    jitter = [float(sample["jitter_ms"]) for sample in stable]
+    rtt = [float(sample["rtt_ms"]) for sample in stable]
+    positive_receive_rates = [value for value in receive_rates if value > 0]
+    final = max(ordered, key=lambda sample: sample["_timestamp"])
+
+    return {
+        "client": int(final["client"]),
+        "sample_count": len(stable),
+        "send_fps_mean": mean(send_rates),
+        "receive_fps_mean": mean(receive_rates),
+        "receive_fps_p5": percentile(receive_rates, 0.05),
+        "receive_fps_min_positive": min(positive_receive_rates, default=0.0),
+        "receive_fps_zero_samples": sum(value == 0 for value in receive_rates),
+        "sent_frames": sent_delta,
+        "received_frames": received_delta,
+        "frame_gap_pct": (
+            (sent_delta - received_delta) / sent_delta * 100 if sent_delta else 0.0
+        ),
+        "received_packets": packet_delta,
+        "lost_packets": lost_delta,
+        "packet_loss_pct": (
+            lost_delta / (packet_delta + lost_delta) * 100
+            if packet_delta + lost_delta
+            else 0.0
+        ),
+        "jitter_mean_ms": mean(jitter),
+        "jitter_p95_ms": percentile(jitter, 0.95),
+        "jitter_max_ms": max(jitter),
+        "rtt_mean_ms": mean(rtt),
+        "rtt_p95_ms": percentile(rtt, 0.95),
+        "rtt_max_ms": max(rtt),
+        "connected": bool(final["connected"]),
+        "failed": bool(final["failed"]),
+        "pc_state": final["pc_state"],
+        "ice_state": final["ice_state"],
+        "error": final.get("error", ""),
+    }
+
+
+def analyze_server(
+    server_run_dir: Path,
+    first_connected_at: datetime,
+    stable_start: datetime,
+    stable_end: datetime,
+    target_clients: int,
+) -> dict[str, Any]:
+    rows = load_csv(server_run_dir / "app.csv")
+    numeric_fields = (
+        "active_sessions",
+        "queue_size",
+        "received_bypass",
+        "processed_bypass",
+        "dropped_bypass",
+        "failures_bypass",
+        "process_cpu_seconds",
+        "process_rss_bytes",
+    )
+    parsed: list[dict[str, Any]] = []
+    for row in rows:
+        converted: dict[str, Any] = {"timestamp": parse_time(row["timestamp"])}
+        for field in numeric_fields:
+            converted[field] = float(row[field])
+        parsed.append(converted)
+
+    first_active = next(row for row in parsed if row["active_sessions"] > 0)
+    clock_offset = first_connected_at - first_active["timestamp"]
+    server_stable_start = stable_start - clock_offset
+    server_stable_end = stable_end - clock_offset
+    target_active = [
+        row for row in parsed if row["active_sessions"] == target_clients
+    ]
+    before_candidates = [
+        row for row in target_active if row["timestamp"] <= server_stable_start
+    ]
+    after_candidates = [
+        row for row in target_active if row["timestamp"] <= server_stable_end
+    ]
+    if not before_candidates or not after_candidates:
+        raise ValueError(f"{server_run_dir.name}: server samples do not span client window")
+    before = max(before_candidates, key=lambda row: row["timestamp"])
+    after = max(after_candidates, key=lambda row: row["timestamp"])
+    stable = [
+        row for row in parsed if before["timestamp"] <= row["timestamp"] <= after["timestamp"]
+    ]
+    duration = (after["timestamp"] - before["timestamp"]).total_seconds()
+    if duration <= 0:
+        raise ValueError(f"{server_run_dir.name}: invalid stable duration")
+
+    received = after["received_bypass"] - before["received_bypass"]
+    processed = after["processed_bypass"] - before["processed_bypass"]
+    dropped = after["dropped_bypass"] - before["dropped_bypass"]
+    failures = after["failures_bypass"] - before["failures_bypass"]
+    cpu_seconds = after["process_cpu_seconds"] - before["process_cpu_seconds"]
+    queue_values = [row["queue_size"] for row in stable]
+    active_values = [row["active_sessions"] for row in stable]
+    rss_values = [row["process_rss_bytes"] for row in stable]
+
+    sessions_final = json.loads(
+        (server_run_dir / "sessions-final.json").read_text(encoding="utf-8-sig")
+    )
+    health_final = json.loads(
+        (server_run_dir / "health-final.json").read_text(encoding="utf-8-sig")
+    )
+    queue_non_increasing = queue_values[-1] <= queue_values[0]
+
+    result = {
+        "clock_offset_seconds": clock_offset.total_seconds(),
+        "sample_count": len(stable),
+        "stable_start": before["timestamp"].isoformat(),
+        "stable_end": after["timestamp"].isoformat(),
+        "stable_duration_seconds": duration,
+        "active_sessions_min": min(active_values),
+        "active_sessions_max": max(active_values),
+        "received_frames": received,
+        "processed_frames": processed,
+        "aggregate_process_fps": processed / duration,
+        "per_session_process_fps": processed / duration / target_clients,
+        "stale_drops": dropped,
+        "stale_drop_pct": dropped / received * 100 if received else 0.0,
+        "failures": failures,
+        "failure_pct": failures / received * 100 if received else 0.0,
+        "cpu_cores_mean": cpu_seconds / duration,
+        "rss_mean_mib": mean(rss_values) / 1024 / 1024,
+        "rss_max_mib": max(rss_values) / 1024 / 1024,
+        "queue_start": queue_values[0],
+        "queue_end": queue_values[-1],
+        "queue_max": max(queue_values),
+        "queue_non_increasing": queue_non_increasing,
+        "final_sessions": sessions_final.get("sessions", []),
+        "final_health": health_final.get("status"),
+    }
+    result["server_pass"] = (
+        result["per_session_process_fps"] >= 27
+        and result["stale_drop_pct"] <= 10
+        and result["failure_pct"] <= 0.1
+        and result["queue_non_increasing"]
+        and not result["final_sessions"]
+        and result["final_health"] == "ready"
+    )
+    return result
+
+
+def analyze_run(json_path: Path, server_root: Path) -> dict[str, Any]:
+    match = RUN_RE.match(json_path.name)
+    if not match:
+        raise ValueError(f"unsupported run name: {json_path.name}")
+    target_clients = int(match.group("clients"))
+    cycle = int(match.group("cycle"))
+    run_name = json_path.stem
+    log_path = json_path.with_suffix(".log")
+    csv_path = json_path.with_suffix(".csv")
+    server_run_dir = server_root / run_name
+
+    payload = json.loads(json_path.read_text(encoding="utf-8"))
+    all_connected_at = last_connected_at(log_path, target_clients)
+    stable_start = all_connected_at + timedelta(seconds=30)
+    stable_end = parse_time(payload["finished_at"])
+
+    grouped: dict[int, list[dict[str, Any]]] = defaultdict(list)
+    for sample in payload["samples"]:
+        sample["_timestamp"] = parse_time(sample["timestamp"])
+        grouped[int(sample["client"])].append(sample)
+    if sorted(grouped) != list(range(1, target_clients + 1)):
+        raise ValueError(f"{run_name}: incomplete client set {sorted(grouped)}")
+
+    clients = [
+        analyze_client(grouped[client], stable_start, stable_end)
+        for client in sorted(grouped)
+    ]
+    connection_successes = sum(
+        client["connected"]
+        and not client["failed"]
+        and client["pc_state"] == "connected"
+        and client["ice_state"] == "connected"
+        for client in clients
+    )
+    client_pass = (
+        connection_successes / target_clients >= 0.99
+        and all(client["receive_fps_mean"] >= 27 for client in clients)
+        and all(client["frame_gap_pct"] <= 10 for client in clients)
+    )
+    connection_times: list[datetime] = []
+    for line in log_path.read_text(encoding="utf-8").splitlines():
+        connection_match = CONNECTED_RE.match(line.strip())
+        if connection_match:
+            connection_times.append(
+                datetime.strptime(
+                    connection_match.group("time"), "%Y/%m/%d %H:%M:%S"
+                ).replace(tzinfo=KST)
+            )
+    first_connected_at = min(connection_times)
+    server = analyze_server(
+        server_run_dir,
+        first_connected_at,
+        stable_start,
+        stable_end,
+        target_clients,
+    )
+
+    return {
+        "run": run_name,
+        "target_clients": target_clients,
+        "cycle": cycle,
+        "started_at": payload["started_at"],
+        "finished_at": payload["finished_at"],
+        "all_connected_at": all_connected_at.isoformat(),
+        "stable_start": stable_start.isoformat(),
+        "stable_duration_seconds": (stable_end - stable_start).total_seconds(),
+        "client_mean_receive_fps": mean(
+            client["receive_fps_mean"] for client in clients
+        ),
+        "client_min_receive_fps": min(
+            client["receive_fps_mean"] for client in clients
+        ),
+        "client_mean_frame_gap_pct": mean(
+            client["frame_gap_pct"] for client in clients
+        ),
+        "client_max_frame_gap_pct": max(
+            client["frame_gap_pct"] for client in clients
+        ),
+        "client_max_rtt_p95_ms": max(client["rtt_p95_ms"] for client in clients),
+        "connection_successes": connection_successes,
+        "connection_attempts": target_clients,
+        "client_pass": client_pass,
+        "combined_pass": client_pass and server["server_pass"],
+        "clients": clients,
+        "server": server,
+        "artifacts": {
+            path.name: {"bytes": path.stat().st_size, "sha256": sha256(path)}
+            for path in (csv_path, json_path, log_path)
+        },
+        "server_artifacts": {
+            path.name: {"bytes": path.stat().st_size, "sha256": sha256(path)}
+            for path in sorted(server_run_dir.iterdir())
+            if path.is_file()
+        },
+    }
+
+
+def summarize(runs: list[dict[str, Any]]) -> dict[str, Any]:
+    grouped: dict[int, list[dict[str, Any]]] = defaultdict(list)
+    for run in runs:
+        grouped[run["target_clients"]].append(run)
+
+    session_summaries: dict[str, Any] = {}
+    for target_clients, session_runs in sorted(grouped.items()):
+        receive_fps = [run["client_mean_receive_fps"] for run in session_runs]
+        server_fps = [run["server"]["per_session_process_fps"] for run in session_runs]
+        received = sum(run["server"]["received_frames"] for run in session_runs)
+        dropped = sum(run["server"]["stale_drops"] for run in session_runs)
+        failures = sum(run["server"]["failures"] for run in session_runs)
+        session_summaries[str(target_clients)] = {
+            "runs": len(session_runs),
+            "client_passes": sum(run["client_pass"] for run in session_runs),
+            "combined_passes": sum(run["combined_pass"] for run in session_runs),
+            "client_receive_fps_mean": mean(receive_fps),
+            "client_receive_fps_population_stddev": population_stddev(receive_fps),
+            "client_receive_fps_min": min(receive_fps),
+            "client_receive_fps_max": max(receive_fps),
+            "client_frame_gap_pct_mean": mean(
+                run["client_mean_frame_gap_pct"] for run in session_runs
+            ),
+            "client_frame_gap_pct_max": max(
+                run["client_max_frame_gap_pct"] for run in session_runs
+            ),
+            "client_rtt_p95_max_mean_ms": mean(
+                run["client_max_rtt_p95_ms"] for run in session_runs
+            ),
+            "client_rtt_p95_max_ms": max(
+                run["client_max_rtt_p95_ms"] for run in session_runs
+            ),
+            "server_per_session_fps_mean": mean(server_fps),
+            "server_per_session_fps_population_stddev": population_stddev(server_fps),
+            "server_per_session_fps_min": min(server_fps),
+            "server_per_session_fps_max": max(server_fps),
+            "server_stale_drop_pct_weighted": dropped / received * 100,
+            "server_failure_pct_weighted": failures / received * 100,
+            "server_cpu_cores_mean": mean(
+                run["server"]["cpu_cores_mean"] for run in session_runs
+            ),
+            "server_rss_mean_mib": mean(
+                run["server"]["rss_mean_mib"] for run in session_runs
+            ),
+            "server_rss_max_mib": max(
+                run["server"]["rss_max_mib"] for run in session_runs
+            ),
+            "server_queue_max": max(
+                run["server"]["queue_max"] for run in session_runs
+            ),
+        }
+
+    return {
+        "run_count": len(runs),
+        "client_passes": sum(run["client_pass"] for run in runs),
+        "combined_passes": sum(run["combined_pass"] for run in runs),
+        "sessions": session_summaries,
+    }
+
+
+def render_manifest(runs: list[dict[str, Any]]) -> str:
+    lines = [
+        "# Python bypass 반복 시험 원본 매니페스트",
+        "",
+        "이 문서는 2026-07-17 `1 → 2 → 4 → 8`세션 3회 반복 시험의 로컬 원본을",
+        "식별합니다. SHA-256은 시험 PC에 보관된 파일에서 계산했습니다. 비공개 리소스",
+        "저장소 업로드와 불변 커밋 링크 추가는 아직 진행하지 않았습니다.",
+        "",
+        "## 클라이언트 원본",
+        "",
+        "| 실행 | 파일 | 크기(byte) | SHA-256 |",
+        "| --- | --- | ---: | --- |",
+    ]
+    for run in runs:
+        for filename, artifact in sorted(run["artifacts"].items()):
+            lines.append(
+                f"| `{run['run']}` | `{filename}` | {artifact['bytes']:,} | "
+                f"`{artifact['sha256']}` |"
+            )
+
+    lines.extend(
+        [
+            "",
+            "## 서버 원본",
+            "",
+            "| 실행 | 파일 | 크기(byte) | SHA-256 |",
+            "| --- | --- | ---: | --- |",
+        ]
+    )
+    for run in runs:
+        for filename, artifact in sorted(run["server_artifacts"].items()):
+            lines.append(
+                f"| `{run['run']}` | `{filename}` | {artifact['bytes']:,} | "
+                f"`{artifact['sha256']}` |"
+            )
+
+    lines.extend(
+        [
+            "",
+            "## 검증 방법",
+            "",
+            "```powershell",
+            'Get-FileHash -Algorithm SHA256 -LiteralPath ".\\파일명"',
+            "```",
+            "",
+            "클라이언트 원본은 현재 `C:/Users/kimFi/Downloads/`, 서버 원본은",
+            "`loadtest/server-results/bypass-*-clients-5m-cycle*/`에 있습니다. 문서 커밋과",
+            "별개로 비공개 리소스 저장소에 보관한 뒤 이 매니페스트에 불변 커밋을 추가해야",
+            "외부 리뷰어가 동일 파일을 내려받아 검증할 수 있습니다.",
+        ]
+    )
+    return "\n".join(lines) + "\n"
+
+
+def main() -> None:
+    args = parse_args()
+    json_paths = sorted(
+        (
+            path
+            for path in args.client_dir.glob("bypass-*-clients-5m-cycle*.json")
+            if RUN_RE.match(path.name)
+        ),
+        key=lambda path: (
+            int(RUN_RE.match(path.name).group("cycle")),
+            int(RUN_RE.match(path.name).group("clients")),
+        ),
+    )
+    if len(json_paths) != 12:
+        raise ValueError(f"expected 12 client JSON files, found {len(json_paths)}")
+    runs = [analyze_run(path, args.server_dir) for path in json_paths]
+    output = {"summary": summarize(runs), "runs": runs}
+    rendered = json.dumps(output, ensure_ascii=False, indent=2)
+    if args.output:
+        args.output.parent.mkdir(parents=True, exist_ok=True)
+        args.output.write_text(rendered + "\n", encoding="utf-8")
+    else:
+        print(rendered)
+    if args.manifest_output:
+        args.manifest_output.parent.mkdir(parents=True, exist_ok=True)
+        args.manifest_output.write_text(render_manifest(runs), encoding="utf-8")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/loadtest/windows/collect-server-metrics.ps1 b/loadtest/windows/collect-server-metrics.ps1
index d0655c9..767354f 100644
--- a/loadtest/windows/collect-server-metrics.ps1
+++ b/loadtest/windows/collect-server-metrics.ps1
@@ -56,6 +56,16 @@ function Assert-MetricFamily {
     }
 }
 
+function Test-MetricFamily {
+    param(
+        [string]$Text,
+        [string]$Name
+    )
+
+    $escapedName = [regex]::Escape($Name)
+    return [regex]::IsMatch($Text, "(?m)^# TYPE ${escapedName} ")
+}
+
 New-Item -ItemType Directory -Force -Path $OutputDirectory | Out-Null
 $initialMetricsPath = Join-Path $OutputDirectory "metrics-initial.prom"
 $finalMetricsPath = Join-Path $OutputDirectory "metrics-final.prom"
@@ -76,11 +86,22 @@ $requiredMetricFamilies = @(
 foreach ($metricName in $requiredMetricFamilies) {
     Assert-MetricFamily -Text $initialMetrics -Name $metricName
 }
+$hasProcessTreeMetrics = (
+    (Test-MetricFamily -Text $initialMetrics -Name "innolive_process_tree_cpu_seconds_total") -and
+    (Test-MetricFamily -Text $initialMetrics -Name "innolive_process_tree_resident_memory_bytes")
+)
+$resourceScope = if ($hasProcessTreeMetrics) {
+    "server_and_ffmpeg_children"
+} else {
+    "server_process_only"
+}
+"resource_scope=$resourceScope" |
+    Set-Content -Encoding utf8 -Path (Join-Path $OutputDirectory "resource-scope.txt")
 $initialMetrics | Set-Content -Encoding utf8 -Path $initialMetricsPath
 (Invoke-WebRequest -UseBasicParsing -Uri "$BaseUrl/health" -TimeoutSec 5).Content |
     Set-Content -Encoding utf8 -Path (Join-Path $OutputDirectory "health-initial.json")
 
-"timestamp,active_sessions,queue_size,received_$Mode,processed_$Mode,dropped_$Mode,failures_$Mode,process_cpu_seconds,process_rss_bytes" |
+"timestamp,active_sessions,queue_size,received_$Mode,processed_$Mode,dropped_$Mode,failures_$Mode,rtp_packets_received_$Mode,rtp_sequence_gaps_$Mode,rtp_packets_recovered_$Mode,rtp_ingress_dropped_$Mode,rtp_out_of_order_$Mode,rtp_packets_discarded_$Mode,rtp_frames_assembled_$Mode,process_cpu_seconds,process_rss_bytes,process_tree_cpu_seconds,process_tree_rss_bytes" |
     Set-Content -Encoding utf8 -Path $samplesPath
 
 Write-Host "Waiting for an active WebRTC session (timeout: ${WaitTimeoutSeconds}s)"
@@ -123,10 +144,27 @@ do {
     $processed = Get-MetricValue -Text $metrics -Name "innolive_frame_processed_total" -Labels $modeLabels
     $dropped = Get-MetricValue -Text $metrics -Name "innolive_frame_dropped_total" -Labels $modeLabels -ZeroIfMissing
     $failures = Get-MetricValue -Text $metrics -Name "innolive_frame_failures_total" -Labels $modeLabels -ZeroIfMissing
+    $rtpPacketsReceived = Get-MetricValue -Text $metrics -Name "innolive_rtp_packets_received_total" -Labels $modeLabels -ZeroIfMissing
+    $rtpSequenceGaps = Get-MetricValue -Text $metrics -Name "innolive_rtp_sequence_gaps_total" -Labels $modeLabels -ZeroIfMissing
+    $rtpPacketsRecovered = Get-MetricValue -Text $metrics -Name "innolive_rtp_packets_recovered_total" -Labels $modeLabels -ZeroIfMissing
+    $rtpIngressDropped = Get-MetricValue -Text $metrics -Name "innolive_rtp_ingress_packets_dropped_total" -Labels $modeLabels -ZeroIfMissing
+    $rtpOutOfOrder = Get-MetricValue -Text $metrics -Name "innolive_rtp_out_of_order_total" -Labels $modeLabels -ZeroIfMissing
+    $rtpPacketsDiscarded = Get-MetricValue -Text $metrics -Name "innolive_rtp_packets_discarded_total" -Labels $modeLabels -ZeroIfMissing
+    $rtpFramesAssembled = Get-MetricValue -Text $metrics -Name "innolive_rtp_frames_assembled_total" -Labels $modeLabels -ZeroIfMissing
     $cpu = Get-MetricValue -Text $metrics -Name "process_cpu_seconds_total"
     $rss = Get-MetricValue -Text $metrics -Name "process_resident_memory_bytes"
+    $treeCPU = if ($hasProcessTreeMetrics) {
+        Get-MetricValue -Text $metrics -Name "innolive_process_tree_cpu_seconds_total"
+    } else {
+        $cpu
+    }
+    $treeRSS = if ($hasProcessTreeMetrics) {
+        Get-MetricValue -Text $metrics -Name "innolive_process_tree_resident_memory_bytes"
+    } else {
+        $rss
+    }
 
-    "$timestamp,$active,$queue,$received,$processed,$dropped,$failures,$cpu,$rss" |
+    "$timestamp,$active,$queue,$received,$processed,$dropped,$failures,$rtpPacketsReceived,$rtpSequenceGaps,$rtpPacketsRecovered,$rtpIngressDropped,$rtpOutOfOrder,$rtpPacketsDiscarded,$rtpFramesAssembled,$cpu,$rss,$treeCPU,$treeRSS" |
         Add-Content -Encoding utf8 -Path $samplesPath
     Start-Sleep -Seconds $IntervalSeconds
 } while ((Get-Date) -lt $end)
diff --git a/test-docs/results/bypass/1-session.md b/test-docs/results/bypass/1-session.md
new file mode 100644
index 0000000..25b5568
--- /dev/null
+++ b/test-docs/results/bypass/1-session.md
@@ -0,0 +1,58 @@
+# Python bypass — 1세션 반복 기준선
+
+## 시험 범위
+
+- 실행: `bypass-1-clients-5m-cycle1`~`cycle3`
+- 클라이언트 원본: 실행별 `.csv`, `.json`, `.log`
+- 서버 원본: 실행별 `app.csv`, health·metrics·sessions 최종 파일
+- 원본 보관: [비공개 리소스 저장소의 불변 경로](https://github.com/team-framework/server-load-test-resources/tree/69792fd4f23b5af52b18041ba2a8119da2078426/results/2026-07-17/bypass)
+- 원본 검증값: [artifact-manifest.md](artifact-manifest.md)
+- 입력: `720p30.ivf` (1280×720, VP8, 30FPS)
+- 안정 구간: 목표 세션 연결 완료 후 30초를 제외한 약 270초
+- 서버 상태: 하나의 Python/aiortc 프로세스를 12개 전체 실행 동안 유지
+- 결과: **통합 기준 3/3 통과**
+
+맥북과 Windows 수집기 시계가 21.68~26.38초 어긋나 있어 실행별 첫 연결 이벤트로
+오프셋을 보정했습니다. 서버 지표는 1세션이 실제로 활성인 구간만 클라이언트 안정
+구간과 맞춰 집계했습니다.
+
+## 반복 실행 요약
+
+| 회차 | 시작 | 평균 수신 FPS | 프레임 차이 | RTT p95 | 서버 처리 FPS | stale drop | CPU | 평균 RSS | 판정 |
+| ---: | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | --- |
+| 1 | 07-17 04:16:46 | 29.62 | 1.43% | 17.99ms | 29.57 | 1.21% | 0.28코어 | 825.3MiB | 통과 |
+| 2 | 07-17 04:44:06 | 28.95 | 3.66% | 11.44ms | 28.91 | 1.68% | 0.28코어 | 1,420.7MiB | 통과 |
+| 3 | 07-17 05:11:26 | 29.62 | 1.27% | 18.14ms | 29.64 | 1.01% | 0.28코어 | 1,525.0MiB | 통과 |
+
+- 클라이언트 평균 수신 FPS: 29.40, 실행 간 표준편차 0.32
+- 서버 평균 처리 FPS: 29.37, 실행 간 표준편차 0.33
+- 클라이언트 평균 프레임 차이: 2.12%, 최대 3.66%
+- 서버 가중 stale drop: 1.30%
+- 연결 성공률: 3/3 (100%)
+- 서버 처리 오류: 0건, 처리 큐 최댓값: 0
+
+## 클라이언트 상세
+
+| 회차 | 클라이언트 | 평균 수신 FPS | p5 | 프레임 차이 | RTP 손실률 | jitter p95 | RTT p95 | 최종 상태 |
+| ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | --- |
+| 1 | 1 | 29.62 | 28.00 | 1.43% | 0.024% | 4.56ms | 17.99ms | `connected` / `connected` |
+| 2 | 1 | 28.95 | 27.14 | 3.66% | 0.012% | 4.19ms | 11.44ms | `connected` / `connected` |
+| 3 | 1 | 29.62 | 28.15 | 1.27% | 0.071% | 7.62ms | 18.14ms | `connected` / `connected` |
+
+## 서버 상세
+
+| 회차 | 안정 구간 | 수신 / 처리 | 처리 FPS | stale drop | 오류 | 평균/최대 RSS | 종료 세션/큐 |
+| ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
+| 1 | 270.0초 | 7,986 / 7,986 | 29.57 | 97 (1.21%) | 0 | 825.3 / 826.7MiB | 0 / 0 |
+| 2 | 271.0초 | 7,834 / 7,834 | 28.91 | 132 (1.68%) | 0 | 1,420.7 / 1,421.7MiB | 0 / 0 |
+| 3 | 271.0초 | 8,033 / 8,033 | 29.64 | 81 (1.01%) | 0 | 1,525.0 / 1,525.0MiB | 0 / 0 |
+
+## 판정
+
+세 회차 모두 평균 수신·서버 처리 27FPS 이상, 클라이언트 프레임 차이와 서버 stale
+drop 10% 이하, 연결 성공률 99% 이상, 처리 오류율 0.1% 이하를 만족했습니다. 따라서
+1세션 bypass 기준선은 반복 통과입니다.
+
+처리량은 안정적이지만 회차가 진행될수록 같은 프로세스의 RSS 기준선이 높아졌습니다.
+이는 1세션 자체의 메모리 요구량으로 해석하지 않고 전체 `1 → 2 → 4 → 8` 반복 중
+누적된 프로세스 상태로 별도 조사합니다.
diff --git a/test-docs/results/bypass/2-sessions.md b/test-docs/results/bypass/2-sessions.md
new file mode 100644
index 0000000..e7d4b21
--- /dev/null
+++ b/test-docs/results/bypass/2-sessions.md
@@ -0,0 +1,55 @@
+# Python bypass — 2세션 반복 기준선
+
+## 시험 범위
+
+- 실행: `bypass-2-clients-5m-cycle1`~`cycle3`
+- 클라이언트 원본: 실행별 `.csv`, `.json`, `.log`
+- 서버 원본: 실행별 `app.csv`, health·metrics·sessions 최종 파일
+- 원본 보관: [비공개 리소스 저장소의 불변 경로](https://github.com/team-framework/server-load-test-resources/tree/69792fd4f23b5af52b18041ba2a8119da2078426/results/2026-07-17/bypass)
+- 원본 검증값: [artifact-manifest.md](artifact-manifest.md)
+- 입력: `720p30.ivf` (1280×720, VP8, 30FPS)
+- 안정 구간: 목표 세션 연결 완료 후 30초를 제외한 약 270초
+- 결과: **통합 기준 3/3 통과**
+
+맥북과 Windows 수집기 시계의 26.17~26.83초 오프셋을 첫 연결 이벤트로 보정하고,
+서버에서 2세션이 모두 활성인 구간만 사용했습니다.
+
+## 반복 실행 요약
+
+| 회차 | 시작 | 실행 평균 수신 FPS | 최저 세션 FPS | 평균/최대 프레임 차이 | RTT p95 최대 | 서버 세션당 FPS | stale drop | CPU | 평균 RSS | 판정 |
+| ---: | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | --- |
+| 1 | 07-17 04:23:21 | 29.80 | 29.75 | 0.71% / 0.91% | 11.03ms | 29.79 | 0.62% | 0.58코어 | 906.3MiB | 통과 |
+| 2 | 07-17 04:50:41 | 29.62 | 29.60 | 1.27% / 1.33% | 16.63ms | 29.62 | 1.08% | 0.57코어 | 1,422.3MiB | 통과 |
+| 3 | 07-17 05:18:01 | 29.66 | 29.61 | 1.13% / 1.36% | 17.12ms | 29.69 | 0.94% | 0.56코어 | 1,608.6MiB | 통과 |
+
+- 실행 평균 수신 FPS: 29.69, 실행 간 표준편차 0.07
+- 서버 세션당 처리 FPS: 29.70, 실행 간 표준편차 0.07
+- 클라이언트 평균 프레임 차이: 1.04%, 개별 최대 1.36%
+- 서버 가중 stale drop: 0.88%
+- 연결 성공률: 6/6 (100%)
+- 서버 처리 오류: 0건, 처리 큐 최댓값: 0
+
+## 클라이언트 상세
+
+| 회차 | 클라이언트 | 평균 수신 FPS | p5 | 프레임 차이 | RTP 손실률 | jitter p95 | RTT p95 | 최종 상태 |
+| ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | --- |
+| 1 | 1 | 29.75 | 28.08 | 0.91% | 0.000% | 4.60ms | 11.03ms | `connected` / `connected` |
+| 1 | 2 | 29.84 | 28.28 | 0.52% | 0.000% | 4.20ms | 9.74ms | `connected` / `connected` |
+| 2 | 1 | 29.60 | 28.13 | 1.33% | 0.000% | 5.21ms | 9.80ms | `connected` / `connected` |
+| 2 | 2 | 29.64 | 28.08 | 1.21% | 0.000% | 6.90ms | 16.63ms | `connected` / `connected` |
+| 3 | 1 | 29.71 | 28.39 | 0.91% | 0.018% | 6.01ms | 10.64ms | `connected` / `connected` |
+| 3 | 2 | 29.61 | 27.93 | 1.36% | 0.036% | 7.22ms | 17.12ms | `connected` / `connected` |
+
+## 서버 상세
+
+| 회차 | 안정 구간 | 수신 / 처리 | 전체 / 세션당 FPS | stale drop | 오류 | 평균/최대 RSS | 종료 세션/큐 |
+| ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
+| 1 | 270.0초 | 16,087 / 16,087 | 59.57 / 29.79 | 100 (0.62%) | 0 | 906.3 / 908.4MiB | 0 / 0 |
+| 2 | 270.2초 | 16,010 / 16,010 | 59.24 / 29.62 | 173 (1.08%) | 0 | 1,422.3 / 1,422.4MiB | 0 / 0 |
+| 3 | 270.2초 | 16,046 / 16,046 | 59.38 / 29.69 | 151 (0.94%) | 0 | 1,608.6 / 1,608.6MiB | 0 / 0 |
+
+## 판정
+
+모든 클라이언트와 서버 지표가 세 회차 모두 기준을 만족했습니다. 2세션 실행 평균
+FPS의 표준편차가 0.07FPS로 작아 5분 처리량 재현성이 높았습니다. RSS는 같은 서버
+프로세스에 앞선 실행들이 누적된 상태이므로 세션 수만의 효과로 단순 비교하지 않습니다.
diff --git a/test-docs/results/bypass/4-sessions.md b/test-docs/results/bypass/4-sessions.md
new file mode 100644
index 0000000..1a623a5
--- /dev/null
+++ b/test-docs/results/bypass/4-sessions.md
@@ -0,0 +1,62 @@
+# Python bypass — 4세션 반복 기준선
+
+## 시험 범위
+
+- 실행: `bypass-4-clients-5m-cycle1`~`cycle3`
+- 클라이언트 원본: 실행별 `.csv`, `.json`, `.log`
+- 서버 원본: 실행별 `app.csv`, health·metrics·sessions 최종 파일
+- 원본 보관: [비공개 리소스 저장소의 불변 경로](https://github.com/team-framework/server-load-test-resources/tree/69792fd4f23b5af52b18041ba2a8119da2078426/results/2026-07-17/bypass)
+- 원본 검증값: [artifact-manifest.md](artifact-manifest.md)
+- 입력: `720p30.ivf` (1280×720, VP8, 30FPS)
+- 안정 구간: 목표 세션 연결 완료 후 30초를 제외한 약 270초
+- 결과: **통합 기준 3/3 통과**
+
+맥북과 Windows 수집기 시계의 26.52~27.06초 오프셋을 보정하고 서버에서 4세션이
+모두 활성인 표본만 사용했습니다.
+
+## 반복 실행 요약
+
+| 회차 | 시작 | 실행 평균 수신 FPS | 최저 세션 FPS | 평균/최대 프레임 차이 | RTT p95 최대 | 서버 세션당 FPS | stale drop | CPU | 평균 RSS | 판정 |
+| ---: | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | --- |
+| 1 | 07-17 04:30:02 | 29.92 | 29.90 | 0.26% / 0.32% | 25.43ms | 29.94 | 0.21% | 1.39코어 | 1,119.5MiB | 통과 |
+| 2 | 07-17 04:57:22 | 29.89 | 29.86 | 0.37% / 0.44% | 17.65ms | 29.89 | 0.35% | 1.31코어 | 1,509.3MiB | 통과 |
+| 3 | 07-17 05:24:42 | 29.90 | 29.85 | 0.37% / 0.57% | 47.03ms | 29.89 | 0.35% | 1.31코어 | 1,694.6MiB | 통과 |
+
+- 실행 평균 수신 FPS: 29.90, 실행 간 표준편차 0.02
+- 서버 세션당 처리 FPS: 29.90, 실행 간 표준편차 0.02
+- 클라이언트 평균 프레임 차이: 0.33%, 개별 최대 0.57%
+- 서버 가중 stale drop: 0.30%
+- 연결 성공률: 12/12 (100%)
+- 서버 처리 오류: 0건, 처리 큐 최댓값: 0
+
+## 클라이언트 상세
+
+| 회차 | 클라이언트 | 평균 수신 FPS | p5 | 프레임 차이 | RTP 손실률 | jitter p95 | RTT p95 | 최종 상태 |
+| ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | --- |
+| 1 | 1 | 29.92 | 29.59 | 0.28% | 0.000% | 7.07ms | 24.38ms | `connected` / `connected` |
+| 1 | 2 | 29.90 | 29.53 | 0.32% | 0.000% | 5.85ms | 12.67ms | `connected` / `connected` |
+| 1 | 3 | 29.95 | 29.73 | 0.18% | 0.006% | 6.71ms | 23.57ms | `connected` / `connected` |
+| 1 | 4 | 29.92 | 29.59 | 0.25% | 0.000% | 6.32ms | 25.43ms | `connected` / `connected` |
+| 2 | 1 | 29.86 | 29.71 | 0.44% | 0.000% | 6.53ms | 17.65ms | `connected` / `connected` |
+| 2 | 2 | 29.88 | 29.59 | 0.39% | 0.000% | 6.31ms | 14.96ms | `connected` / `connected` |
+| 2 | 3 | 29.92 | 29.60 | 0.25% | 0.006% | 6.07ms | 13.44ms | `connected` / `connected` |
+| 2 | 4 | 29.88 | 29.59 | 0.41% | 0.000% | 6.05ms | 15.00ms | `connected` / `connected` |
+| 3 | 1 | 29.93 | 29.74 | 0.22% | 0.006% | 6.38ms | 47.03ms | `connected` / `connected` |
+| 3 | 2 | 29.85 | 29.40 | 0.57% | 0.000% | 6.60ms | 23.74ms | `connected` / `connected` |
+| 3 | 3 | 29.89 | 29.40 | 0.41% | 0.000% | 6.41ms | 28.26ms | `connected` / `connected` |
+| 3 | 4 | 29.91 | 29.60 | 0.31% | 0.000% | 6.47ms | 36.47ms | `connected` / `connected` |
+
+## 서버 상세
+
+| 회차 | 안정 구간 | 수신 / 처리 | 전체 / 세션당 FPS | stale drop | 오류 | 평균/최대 RSS | 종료 세션/큐 |
+| ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
+| 1 | 269.7초 | 32,296 / 32,296 | 119.75 / 29.94 | 67 (0.21%) | 0 | 1,119.5 / 1,120.8MiB | 0 / 0 |
+| 2 | 270.7초 | 32,363 / 32,363 | 119.56 / 29.89 | 114 (0.35%) | 0 | 1,509.3 / 1,509.5MiB | 0 / 0 |
+| 3 | 270.7초 | 32,362 / 32,362 | 119.54 / 29.89 | 113 (0.35%) | 0 | 1,694.6 / 1,694.6MiB | 0 / 0 |
+
+## 판정
+
+4세션은 세 회차 모두 거의 30FPS를 유지했고 실행 평균 FPS의 표준편차가 0.02FPS로
+가장 작았습니다. 세 번째 회차에서 한 클라이언트의 RTT p95가 47.03ms로 올랐지만
+FPS·프레임 차이·RTP 손실에는 유의미한 악화가 없었습니다. 5분 통합 기준은 3/3
+통과입니다.
diff --git a/test-docs/results/bypass/8-sessions.md b/test-docs/results/bypass/8-sessions.md
new file mode 100644
index 0000000..d89ad82
--- /dev/null
+++ b/test-docs/results/bypass/8-sessions.md
@@ -0,0 +1,80 @@
+# Python bypass — 8세션 반복 기준선
+
+## 시험 범위
+
+- 실행: `bypass-8-clients-5m-cycle1`~`cycle3`
+- 클라이언트 원본: 실행별 `.csv`, `.json`, `.log`
+- 서버 원본: 실행별 `app.csv`, health·metrics·sessions 최종 파일
+- 원본 보관: [비공개 리소스 저장소의 불변 경로](https://github.com/team-framework/server-load-test-resources/tree/69792fd4f23b5af52b18041ba2a8119da2078426/results/2026-07-17/bypass)
+- 원본 검증값: [artifact-manifest.md](artifact-manifest.md)
+- 입력: `720p30.ivf` (1280×720, VP8, 30FPS)
+- 안정 구간: 목표 세션 연결 완료 후 30초를 제외한 약 270초
+- 결과: **통합 기준 3/3 통과**
+
+맥북과 Windows 수집기 시계의 25.96~27.51초 오프셋을 보정하고 서버에서 8세션이
+모두 활성인 표본만 사용했습니다.
+
+## 반복 실행 요약
+
+| 회차 | 시작 | 실행 평균 수신 FPS | 최저 세션 FPS | 평균/최대 프레임 차이 | RTT p95 최대 | 서버 세션당 FPS | stale drop | CPU | 평균 RSS | 판정 |
+| ---: | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | --- |
+| 1 | 07-17 04:36:53 | 29.73 | 29.65 | 0.89% / 1.16% | 54.64ms | 29.73 | 0.86% | 4.11코어 | 1,453.1MiB | 통과 |
+| 2 | 07-17 05:04:13 | 29.73 | 29.68 | 0.93% / 1.09% | 68.83ms | 29.72 | 0.93% | 4.34코어 | 1,565.8MiB | 통과 |
+| 3 | 07-17 05:31:33 | 29.64 | 29.48 | 1.17% / 1.75% | 71.02ms | 29.66 | 1.13% | 4.44코어 | 1,755.6MiB | 통과 |
+
+- 실행 평균 수신 FPS: 29.70, 실행 간 표준편차 0.04
+- 서버 세션당 처리 FPS: 29.70, 실행 간 표준편차 0.03
+- 평균 전체 서버 처리량: 약 237.6FPS
+- 클라이언트 평균 프레임 차이: 1.00%, 개별 최대 1.75%
+- 서버 가중 stale drop: 0.97%
+- 연결 성공률: 24/24 (100%)
+- 서버 처리 오류: 0건, 처리 큐 최댓값: 0
+
+## 클라이언트 상세
+
+| 회차 | 클라이언트 | 평균 수신 FPS | p5 | 프레임 차이 | RTP 손실률 | jitter p95 | RTT p95 | 최종 상태 |
+| ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | --- |
+| 1 | 1 | 29.73 | 29.14 | 0.89% | 0.006% | 9.46ms | 30.94ms | `connected` / `connected` |
+| 1 | 2 | 29.75 | 29.20 | 0.82% | 0.012% | 10.00ms | 46.26ms | `connected` / `connected` |
+| 1 | 3 | 29.83 | 29.20 | 0.57% | 0.018% | 9.09ms | 32.26ms | `connected` / `connected` |
+| 1 | 4 | 29.72 | 28.44 | 0.94% | 0.000% | 9.53ms | 29.71ms | `connected` / `connected` |
+| 1 | 5 | 29.69 | 29.14 | 1.03% | 0.000% | 9.64ms | 45.36ms | `connected` / `connected` |
+| 1 | 6 | 29.65 | 27.94 | 1.16% | 0.006% | 9.89ms | 54.64ms | `connected` / `connected` |
+| 1 | 7 | 29.80 | 29.34 | 0.66% | 0.012% | 8.77ms | 38.45ms | `connected` / `connected` |
+| 1 | 8 | 29.68 | 28.56 | 1.05% | 0.000% | 8.63ms | 36.06ms | `connected` / `connected` |
+| 2 | 1 | 29.73 | 29.20 | 0.92% | 0.012% | 9.31ms | 42.08ms | `connected` / `connected` |
+| 2 | 2 | 29.71 | 29.13 | 0.99% | 0.018% | 8.76ms | 68.83ms | `connected` / `connected` |
+| 2 | 3 | 29.73 | 29.00 | 0.93% | 0.000% | 8.50ms | 49.18ms | `connected` / `connected` |
+| 2 | 4 | 29.68 | 28.87 | 1.09% | 0.000% | 9.04ms | 43.69ms | `connected` / `connected` |
+| 2 | 5 | 29.74 | 29.00 | 0.86% | 0.000% | 8.08ms | 45.72ms | `connected` / `connected` |
+| 2 | 6 | 29.71 | 28.94 | 0.98% | 0.000% | 9.43ms | 56.14ms | `connected` / `connected` |
+| 2 | 7 | 29.75 | 29.20 | 0.84% | 0.000% | 8.07ms | 29.00ms | `connected` / `connected` |
+| 2 | 8 | 29.77 | 28.94 | 0.80% | 0.000% | 8.01ms | 63.49ms | `connected` / `connected` |
+| 3 | 1 | 29.65 | 28.56 | 1.17% | 0.000% | 9.19ms | 44.30ms | `connected` / `connected` |
+| 3 | 2 | 29.48 | 27.94 | 1.75% | 0.006% | 9.97ms | 52.67ms | `connected` / `connected` |
+| 3 | 3 | 29.69 | 28.80 | 1.04% | 0.000% | 9.75ms | 60.11ms | `connected` / `connected` |
+| 3 | 4 | 29.63 | 28.48 | 1.15% | 0.000% | 8.47ms | 55.74ms | `connected` / `connected` |
+| 3 | 5 | 29.66 | 28.94 | 1.11% | 0.000% | 9.18ms | 54.27ms | `connected` / `connected` |
+| 3 | 6 | 29.70 | 29.08 | 1.00% | 0.000% | 8.99ms | 51.71ms | `connected` / `connected` |
+| 3 | 7 | 29.61 | 28.50 | 1.28% | 0.000% | 8.33ms | 71.02ms | `connected` / `connected` |
+| 3 | 8 | 29.73 | 29.00 | 0.88% | 0.000% | 8.46ms | 46.78ms | `connected` / `connected` |
+
+## 서버 상세
+
+| 회차 | 안정 구간 | 수신 / 처리 | 전체 / 세션당 FPS | stale drop | 오류 | 평균/최대 RSS | 종료 세션/큐 |
+| ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
+| 1 | 270.1초 | 64,234 / 64,234 | 237.84 / 29.73 | 553 (0.86%) | 0 | 1,453.1 / 1,462.2MiB | 0 / 0 |
+| 2 | 270.1초 | 64,229 / 64,229 | 237.76 / 29.72 | 599 (0.93%) | 0 | 1,565.8 / 1,567.2MiB | 0 / 0 |
+| 3 | 271.1초 | 64,324 / 64,324 | 237.28 / 29.66 | 725 (1.13%) | 0 | 1,755.6 / 1,865.5MiB | 0 / 0 |
+
+## 판정과 한계
+
+8세션은 모든 회차에서 27FPS와 10% 드롭 기준을 여유 있게 만족했고 실행 간 처리량
+편차도 작았습니다. 따라서 Python bypass의 **반복 가능한 5분 8세션 체크포인트**로
+사용할 수 있습니다.
+
+그러나 8세션이 용량 한계인 것은 아닙니다. 더 높은 세션 수를 시험하지 않았고 30분
+지속 조건도 검증하지 않았습니다. 평균 CPU는 4.11 → 4.34 → 4.44코어로 증가했고 같은
+프로세스의 RSS도 1,453.1 → 1,565.8 → 1,755.6MiB로 높아졌습니다. Go 서버는 동일한
+8세션 조건에서 전체/세션당 FPS, CPU 코어, RSS와 반복 후 메모리 회복 여부를 우선
+비교해야 합니다.
diff --git a/test-docs/results/bypass/artifact-manifest.md b/test-docs/results/bypass/artifact-manifest.md
new file mode 100644
index 0000000..abcb485
--- /dev/null
+++ b/test-docs/results/bypass/artifact-manifest.md
@@ -0,0 +1,140 @@
+# Python bypass 반복 시험 원본 매니페스트
+
+이 문서는 2026-07-17 `1 → 2 → 4 → 8`세션 3회 반복 시험의 원본을 식별합니다.
+SHA-256은 시험 PC에 보관된 파일에서 계산했고, 업로드된 Git blob이 로컬 원본과
+바이트 단위로 일치하는지 확인했습니다.
+
+클라이언트 36개와 서버 72개 원본은 비공개
+[`team-framework/server-load-test-resources`](https://github.com/team-framework/server-load-test-resources/tree/69792fd4f23b5af52b18041ba2a8119da2078426)
+저장소의 불변 커밋 `69792fd4f23b5af52b18041ba2a8119da2078426`에 있습니다.
+
+- 클라이언트 원본: [`results/2026-07-17/bypass/client/`](https://github.com/team-framework/server-load-test-resources/tree/69792fd4f23b5af52b18041ba2a8119da2078426/results/2026-07-17/bypass/client)
+- 서버 원본: [`results/2026-07-17/bypass/server/`](https://github.com/team-framework/server-load-test-resources/tree/69792fd4f23b5af52b18041ba2a8119da2078426/results/2026-07-17/bypass/server)
+
+## 클라이언트 원본
+
+| 실행 | 파일 | 크기(byte) | SHA-256 |
+| --- | --- | ---: | --- |
+| `bypass-1-clients-5m-cycle1` | `bypass-1-clients-5m-cycle1.csv` | 10,689 | `F24F21C7571ACC1A4166E35401BB7B554C4BBF05C62473291FBF7FF396834085` |
+| `bypass-1-clients-5m-cycle1` | `bypass-1-clients-5m-cycle1.json` | 39,574 | `8C67D44485BE503753B138F965BA65A38DB70195737E01C67648E9C1D3FF3103` |
+| `bypass-1-clients-5m-cycle1` | `bypass-1-clients-5m-cycle1.log` | 6,199 | `79A512E2C75EF81DE4F1B53D59E4589AA3A06677A2D77C7CFC9F0AF9E7D33506` |
+| `bypass-2-clients-5m-cycle1` | `bypass-2-clients-5m-cycle1.csv` | 21,300 | `643D972EA5E3E5C9F432FE8D2B806A14DD591781AA791ECA2E93E3224CD780DF` |
+| `bypass-2-clients-5m-cycle1` | `bypass-2-clients-5m-cycle1.json` | 77,648 | `4CC9F1BBB614971A61EA658281CBA4F1219126F92F6ED6EB57F00445776325D2` |
+| `bypass-2-clients-5m-cycle1` | `bypass-2-clients-5m-cycle1.log` | 6,442 | `4BB828F87B25EDA10DDD9278887B387A7EBDCE3F9EBC1C6E2685AE0BB88AF163` |
+| `bypass-4-clients-5m-cycle1` | `bypass-4-clients-5m-cycle1.csv` | 43,125 | `44101392F1FBFEBF8483F2AA397C4EDB0D5B3B4B0BF3595D0452BB07EE843630` |
+| `bypass-4-clients-5m-cycle1` | `bypass-4-clients-5m-cycle1.json` | 157,555 | `1DDB654F3842B092BB946A58271863350FA930127F20469F8785BF817AA22AB2` |
+| `bypass-4-clients-5m-cycle1` | `bypass-4-clients-5m-cycle1.log` | 6,837 | `256F07DADCCC619ABD89727DFF5F6DE41B37EA75F2A2ECFD2DD9DB50D916ADC0` |
+| `bypass-8-clients-5m-cycle1` | `bypass-8-clients-5m-cycle1.csv` | 88,918 | `A68F3F97EC5EBFC444E179BFA9E9094F08C5E95C59B4AF0B89E12425631B9C3C` |
+| `bypass-8-clients-5m-cycle1` | `bypass-8-clients-5m-cycle1.json` | 327,973 | `6ED8D93F3B40BB5167EA97E08371220D42B7EDBEF2BC743519DD20C9D9803380` |
+| `bypass-8-clients-5m-cycle1` | `bypass-8-clients-5m-cycle1.log` | 7,577 | `BCF44A04AA44D9425D1B10025FA430E81D6AD44993E399AD5331E3520DE46D56` |
+| `bypass-1-clients-5m-cycle2` | `bypass-1-clients-5m-cycle2.csv` | 10,677 | `82037CA5E92EBCB0EE54710ACB6499A8D756A90DCA87CB27022A6DA83EB77A23` |
+| `bypass-1-clients-5m-cycle2` | `bypass-1-clients-5m-cycle2.json` | 39,686 | `672D865F385707DC0A8AD4E791A2F410DE782D35250C9056D297E9D434AE3DD2` |
+| `bypass-1-clients-5m-cycle2` | `bypass-1-clients-5m-cycle2.log` | 6,199 | `ADD11AD8D7669BF89EFB0DC45857FD1DBC118E550DF9ACA1F91B7050A6B1BE2E` |
+| `bypass-2-clients-5m-cycle2` | `bypass-2-clients-5m-cycle2.csv` | 21,304 | `D99F0E4FE7346CEE7B2E253ED36AB2A5D1F4496B044E923A009DB9D194A824CC` |
+| `bypass-2-clients-5m-cycle2` | `bypass-2-clients-5m-cycle2.json` | 77,617 | `0B320EB7EBEF926798F3B2CFC99D69A94EEA1CFC50E49A2C63A744F3651E4B76` |
+| `bypass-2-clients-5m-cycle2` | `bypass-2-clients-5m-cycle2.log` | 6,442 | `66D079FF065BE34FFD0B5274ECACE1A90AD7C91C4FCF62B13D8C263E9CACC941` |
+| `bypass-4-clients-5m-cycle2` | `bypass-4-clients-5m-cycle2.csv` | 43,073 | `166D2C1AB2D9DABB0A9894B372BD83398E0FC91FA29AAA65488444B333A560C8` |
+| `bypass-4-clients-5m-cycle2` | `bypass-4-clients-5m-cycle2.json` | 157,699 | `4D8356F3A046F67B898367EE395C8D180EDCFE0261D9059E6B136BF0F24400BB` |
+| `bypass-4-clients-5m-cycle2` | `bypass-4-clients-5m-cycle2.log` | 6,837 | `B54E0EF5DBCD4958219BC72BC5E078F5DC645F3A3F94CC79472273A98C2F69C5` |
+| `bypass-8-clients-5m-cycle2` | `bypass-8-clients-5m-cycle2.csv` | 89,032 | `3A944DD237779FCFFD0A7F7A74D63D8E43982ED222BC7B95F5D83A03F1378209` |
+| `bypass-8-clients-5m-cycle2` | `bypass-8-clients-5m-cycle2.json` | 325,708 | `636D56417CCB68B338584736C6F23D13C87954DCEE9CC4C8499BABAA77594284` |
+| `bypass-8-clients-5m-cycle2` | `bypass-8-clients-5m-cycle2.log` | 7,577 | `2BF8F7196D057D4709948A087E8BBA876928B1374BF981D8A814997753341C0F` |
+| `bypass-1-clients-5m-cycle3` | `bypass-1-clients-5m-cycle3.csv` | 10,701 | `711FD975D35C9E9DFD2A111637EAC73446087473A4D5E56B4350C0EF60C77FF0` |
+| `bypass-1-clients-5m-cycle3` | `bypass-1-clients-5m-cycle3.json` | 39,283 | `998A6F577A9ECCA00FE2ACFE43B757783E4562C73399C40C2F3856CE25E113F8` |
+| `bypass-1-clients-5m-cycle3` | `bypass-1-clients-5m-cycle3.log` | 6,199 | `EEFBE9EDC2631C2B799CC43B7C5C96A50BFE6C69C67673903373F256D54C4C02` |
+| `bypass-2-clients-5m-cycle3` | `bypass-2-clients-5m-cycle3.csv` | 21,310 | `F5E393254D963803A419CFF905345AEB7993693CD223C1E76E6D508F7F053782` |
+| `bypass-2-clients-5m-cycle3` | `bypass-2-clients-5m-cycle3.json` | 79,119 | `F92156C3484E9B18095CD6C3BDAECE931DCB619A1CC8B2CA61EAE15D3EA931F2` |
+| `bypass-2-clients-5m-cycle3` | `bypass-2-clients-5m-cycle3.log` | 6,442 | `656A099E95F5FA7DE6B9E436696E8BE284DFC14AD39AF843BF26EFD40684A0C2` |
+| `bypass-4-clients-5m-cycle3` | `bypass-4-clients-5m-cycle3.csv` | 43,152 | `8A25DDD9D90F7DA3A0B212ED8C59776889BE3773A1B3DC3ECFBFBE3D185D89FF` |
+| `bypass-4-clients-5m-cycle3` | `bypass-4-clients-5m-cycle3.json` | 157,320 | `2876B05B2F0F446849BAFEE78D2356E2F8EEB81589450C573036A0FF307E9AB3` |
+| `bypass-4-clients-5m-cycle3` | `bypass-4-clients-5m-cycle3.log` | 6,837 | `43567A0E96ECB0C794B6C4F6624B87990CC07BA790973B8A39FEBABEF6F3EF8F` |
+| `bypass-8-clients-5m-cycle3` | `bypass-8-clients-5m-cycle3.csv` | 88,924 | `BA63B8DA3701ABE0290A464CFAD25A31A7CC6BA41B473BCA077AA13408C610C4` |
+| `bypass-8-clients-5m-cycle3` | `bypass-8-clients-5m-cycle3.json` | 324,903 | `7EDAC9069E36563C8CB39EC6CE04062B41B5B0BDA5DE28D6D6916375234A7741` |
+| `bypass-8-clients-5m-cycle3` | `bypass-8-clients-5m-cycle3.log` | 7,577 | `2754CFFF767CD5C0D50ED3E11495B2A0A910E820AD4C74F9F301BABF50F78292` |
+
+## 서버 원본
+
+| 실행 | 파일 | 크기(byte) | SHA-256 |
+| --- | --- | ---: | --- |
+| `bypass-1-clients-5m-cycle1` | `app.csv` | 24,858 | `1B60F6C6FE48CACC92D5ABD3A6835E30497E0DB3E0DDEAF92FC02A806E9263CF` |
+| `bypass-1-clients-5m-cycle1` | `health-final.json` | 69 | `5936C07B4C0D45415F51B830B3E607724DD20A0A0823207861BFA8C4206A0825` |
+| `bypass-1-clients-5m-cycle1` | `health-initial.json` | 69 | `5936C07B4C0D45415F51B830B3E607724DD20A0A0823207861BFA8C4206A0825` |
+| `bypass-1-clients-5m-cycle1` | `metrics-final.prom` | 6,221 | `651A592882C9B86D7A100C2C539FD06D2B6159ABC38FFE8DDD6794D8689ED46F` |
+| `bypass-1-clients-5m-cycle1` | `metrics-initial.prom` | 4,137 | `DDC3DE82ADC6BEB4E5FA771622AD1D383A75A835B7FBF8D7465E81FBC50EBD13` |
+| `bypass-1-clients-5m-cycle1` | `sessions-final.json` | 20 | `6254B38AB0F4A29C5B05C0319B3CBF2EA4F0A655F2D14B52E3D3842D9ADCD877` |
+| `bypass-2-clients-5m-cycle1` | `app.csv` | 26,238 | `B82968380624CAD2BAEE265C8A8BD65278F0627CC9F278A7DC3B856E9CB3CDF0` |
+| `bypass-2-clients-5m-cycle1` | `health-final.json` | 69 | `5936C07B4C0D45415F51B830B3E607724DD20A0A0823207861BFA8C4206A0825` |
+| `bypass-2-clients-5m-cycle1` | `health-initial.json` | 69 | `5936C07B4C0D45415F51B830B3E607724DD20A0A0823207861BFA8C4206A0825` |
+| `bypass-2-clients-5m-cycle1` | `metrics-final.prom` | 6,251 | `AF90305A759F3AA7B4F0F55D604DF643458D03BAEF2EB269ACB0D4D8F8D0A3F9` |
+| `bypass-2-clients-5m-cycle1` | `metrics-initial.prom` | 6,221 | `651A592882C9B86D7A100C2C539FD06D2B6159ABC38FFE8DDD6794D8689ED46F` |
+| `bypass-2-clients-5m-cycle1` | `sessions-final.json` | 20 | `6254B38AB0F4A29C5B05C0319B3CBF2EA4F0A655F2D14B52E3D3842D9ADCD877` |
+| `bypass-4-clients-5m-cycle1` | `app.csv` | 26,568 | `FC147EA92B4F999C2D2D36F49A2BEE1A77C783F33057741D0C6E5E2010C6D849` |
+| `bypass-4-clients-5m-cycle1` | `health-final.json` | 69 | `5936C07B4C0D45415F51B830B3E607724DD20A0A0823207861BFA8C4206A0825` |
+| `bypass-4-clients-5m-cycle1` | `health-initial.json` | 69 | `5936C07B4C0D45415F51B830B3E607724DD20A0A0823207861BFA8C4206A0825` |
+| `bypass-4-clients-5m-cycle1` | `metrics-final.prom` | 6,252 | `CF4CAEA587E7F4F90BE3B8D8405C57771B1942FB2222C784BDB5C571130C702B` |
+| `bypass-4-clients-5m-cycle1` | `metrics-initial.prom` | 6,250 | `3AA37AD14AB02541F9E75DCC49AC03F9045F99E81F1B40044BD35B926DF2FD2D` |
+| `bypass-4-clients-5m-cycle1` | `sessions-final.json` | 20 | `6254B38AB0F4A29C5B05C0319B3CBF2EA4F0A655F2D14B52E3D3842D9ADCD877` |
+| `bypass-8-clients-5m-cycle1` | `app.csv` | 26,959 | `62DF58BD26A662CA89FA6833D54001B870589BC3ADC686D2B1E30680C7C0266C` |
+| `bypass-8-clients-5m-cycle1` | `health-final.json` | 69 | `5936C07B4C0D45415F51B830B3E607724DD20A0A0823207861BFA8C4206A0825` |
+| `bypass-8-clients-5m-cycle1` | `health-initial.json` | 69 | `5936C07B4C0D45415F51B830B3E607724DD20A0A0823207861BFA8C4206A0825` |
+| `bypass-8-clients-5m-cycle1` | `metrics-final.prom` | 6,258 | `85F104D77870543F78EEA86ACFE397B78111E97C6243A5311C165A950C0B3FAC` |
+| `bypass-8-clients-5m-cycle1` | `metrics-initial.prom` | 6,251 | `44E2B3A390F6E164016B838CA84B0C5CE89763437A442355B31DEE61C6D77585` |
+| `bypass-8-clients-5m-cycle1` | `sessions-final.json` | 20 | `6254B38AB0F4A29C5B05C0319B3CBF2EA4F0A655F2D14B52E3D3842D9ADCD877` |
+| `bypass-1-clients-5m-cycle2` | `app.csv` | 27,994 | `496A344E8B981D44E656771D403B3B9AAE15ADFA634F803E2897D94F15144883` |
+| `bypass-1-clients-5m-cycle2` | `health-final.json` | 69 | `5936C07B4C0D45415F51B830B3E607724DD20A0A0823207861BFA8C4206A0825` |
+| `bypass-1-clients-5m-cycle2` | `health-initial.json` | 69 | `5936C07B4C0D45415F51B830B3E607724DD20A0A0823207861BFA8C4206A0825` |
+| `bypass-1-clients-5m-cycle2` | `metrics-final.prom` | 6,268 | `C06FF21215EEA1555C71AEF070C001595E9FC8ADA5C9C31BF12A3EBF829F9C70` |
+| `bypass-1-clients-5m-cycle2` | `metrics-initial.prom` | 6,256 | `94807614D5E4D2A2AA1F8F106B3665111C9F8C1013127AF4CCF8514BFFE7F083` |
+| `bypass-1-clients-5m-cycle2` | `sessions-final.json` | 20 | `6254B38AB0F4A29C5B05C0319B3CBF2EA4F0A655F2D14B52E3D3842D9ADCD877` |
+| `bypass-2-clients-5m-cycle2` | `app.csv` | 28,061 | `758531B3959D0733437D2C0BAA7D2FA925F63BF39EB2DC3325F4DC7CEFFDF410` |
+| `bypass-2-clients-5m-cycle2` | `health-final.json` | 69 | `5936C07B4C0D45415F51B830B3E607724DD20A0A0823207861BFA8C4206A0825` |
+| `bypass-2-clients-5m-cycle2` | `health-initial.json` | 69 | `5936C07B4C0D45415F51B830B3E607724DD20A0A0823207861BFA8C4206A0825` |
+| `bypass-2-clients-5m-cycle2` | `metrics-final.prom` | 6,260 | `5F988F387F87515062CCF10980559509848C01909511FEF3288CC6D793519046` |
+| `bypass-2-clients-5m-cycle2` | `metrics-initial.prom` | 6,257 | `D153EA119AAE186E1091B3A969AE230FC0DECE5CA4751BAD4FB55CB575DAF730` |
+| `bypass-2-clients-5m-cycle2` | `sessions-final.json` | 20 | `6254B38AB0F4A29C5B05C0319B3CBF2EA4F0A655F2D14B52E3D3842D9ADCD877` |
+| `bypass-4-clients-5m-cycle2` | `app.csv` | 27,991 | `9822CC78950E6403A2E4AFD43DB0050BEE82FE7CA97AB982DA63CA2F0A9351D2` |
+| `bypass-4-clients-5m-cycle2` | `health-final.json` | 69 | `5936C07B4C0D45415F51B830B3E607724DD20A0A0823207861BFA8C4206A0825` |
+| `bypass-4-clients-5m-cycle2` | `health-initial.json` | 69 | `5936C07B4C0D45415F51B830B3E607724DD20A0A0823207861BFA8C4206A0825` |
+| `bypass-4-clients-5m-cycle2` | `metrics-final.prom` | 6,272 | `F76395A809E515B70C98096FE421700A5E52533B55293D26371BD16F6513A0AB` |
+| `bypass-4-clients-5m-cycle2` | `metrics-initial.prom` | 6,269 | `FA032E3AA3D3751BA7C89D4EA9DF1424E29537943CD4EA696E795561A5F33250` |
+| `bypass-4-clients-5m-cycle2` | `sessions-final.json` | 20 | `6254B38AB0F4A29C5B05C0319B3CBF2EA4F0A655F2D14B52E3D3842D9ADCD877` |
+| `bypass-8-clients-5m-cycle2` | `app.csv` | 27,752 | `7631951CC128858EBE2615D49E86CC6726900E601969D0D4B852913FDC167DCD` |
+| `bypass-8-clients-5m-cycle2` | `health-final.json` | 69 | `5936C07B4C0D45415F51B830B3E607724DD20A0A0823207861BFA8C4206A0825` |
+| `bypass-8-clients-5m-cycle2` | `health-initial.json` | 69 | `5936C07B4C0D45415F51B830B3E607724DD20A0A0823207861BFA8C4206A0825` |
+| `bypass-8-clients-5m-cycle2` | `metrics-final.prom` | 6,265 | `61F799AEB90F45B3B522997364D1AD3DFBF5434B4F75880348786B5D5FA2D941` |
+| `bypass-8-clients-5m-cycle2` | `metrics-initial.prom` | 6,272 | `B231134D1F0F8BDB6656B25580FA0E935343C7E44336BCC5F5E63E645D159617` |
+| `bypass-8-clients-5m-cycle2` | `sessions-final.json` | 20 | `6254B38AB0F4A29C5B05C0319B3CBF2EA4F0A655F2D14B52E3D3842D9ADCD877` |
+| `bypass-1-clients-5m-cycle3` | `app.csv` | 28,055 | `80206EC7A03F8CBED01EC090187D5B825C5B5103A508D59EEEDA03825DDEDCC1` |
+| `bypass-1-clients-5m-cycle3` | `health-final.json` | 69 | `5936C07B4C0D45415F51B830B3E607724DD20A0A0823207861BFA8C4206A0825` |
+| `bypass-1-clients-5m-cycle3` | `health-initial.json` | 69 | `5936C07B4C0D45415F51B830B3E607724DD20A0A0823207861BFA8C4206A0825` |
+| `bypass-1-clients-5m-cycle3` | `metrics-final.prom` | 6,263 | `1127C5D1B86E94F0008FB12673AAE5B7340DD47739EC409689C173852FAD09C0` |
+| `bypass-1-clients-5m-cycle3` | `metrics-initial.prom` | 6,264 | `C0EAABE09A081E6ECEE7AD213BF08DA5D66FB4673BB651437CAA6A31E749274D` |
+| `bypass-1-clients-5m-cycle3` | `sessions-final.json` | 20 | `6254B38AB0F4A29C5B05C0319B3CBF2EA4F0A655F2D14B52E3D3842D9ADCD877` |
+| `bypass-2-clients-5m-cycle3` | `app.csv` | 28,071 | `D4A9C93BB1277C61F82F62780FD2C75E46705749D2F282A60E5ABC19F79A491E` |
+| `bypass-2-clients-5m-cycle3` | `health-final.json` | 69 | `5936C07B4C0D45415F51B830B3E607724DD20A0A0823207861BFA8C4206A0825` |
+| `bypass-2-clients-5m-cycle3` | `health-initial.json` | 69 | `5936C07B4C0D45415F51B830B3E607724DD20A0A0823207861BFA8C4206A0825` |
+| `bypass-2-clients-5m-cycle3` | `metrics-final.prom` | 6,265 | `05BFE6AA744477EBF9C8932DC6EE738923F6995CF94238AF842E322CED56B684` |
+| `bypass-2-clients-5m-cycle3` | `metrics-initial.prom` | 6,274 | `7C1532FBD62A25A6596E6246934120CA06E3F227056263AF605ADE6538B6B2C8` |
+| `bypass-2-clients-5m-cycle3` | `sessions-final.json` | 20 | `6254B38AB0F4A29C5B05C0319B3CBF2EA4F0A655F2D14B52E3D3842D9ADCD877` |
+| `bypass-4-clients-5m-cycle3` | `app.csv` | 27,985 | `E44BB67949D0AB2B7B93C885F7BA43B983654E9A5477FBB96EF3FE51B544AB3F` |
+| `bypass-4-clients-5m-cycle3` | `health-final.json` | 69 | `5936C07B4C0D45415F51B830B3E607724DD20A0A0823207861BFA8C4206A0825` |
+| `bypass-4-clients-5m-cycle3` | `health-initial.json` | 69 | `5936C07B4C0D45415F51B830B3E607724DD20A0A0823207861BFA8C4206A0825` |
+| `bypass-4-clients-5m-cycle3` | `metrics-final.prom` | 6,267 | `EF1A14330D7C0E91A2B7E49CF5AC45D6F57405C2872EB8D802FE944EFDA67954` |
+| `bypass-4-clients-5m-cycle3` | `metrics-initial.prom` | 6,265 | `D1E49C38FF910D5A6774B8B522158AFEF7954E17F92FE20CCB4683469806A9FA` |
+| `bypass-4-clients-5m-cycle3` | `sessions-final.json` | 20 | `6254B38AB0F4A29C5B05C0319B3CBF2EA4F0A655F2D14B52E3D3842D9ADCD877` |
+| `bypass-8-clients-5m-cycle3` | `app.csv` | 27,759 | `DBA58A6914A664537F56D9EC0381FD6F115A36B4B6E2E05AC7AB6E1C4F733737` |
+| `bypass-8-clients-5m-cycle3` | `health-final.json` | 69 | `5936C07B4C0D45415F51B830B3E607724DD20A0A0823207861BFA8C4206A0825` |
+| `bypass-8-clients-5m-cycle3` | `health-initial.json` | 69 | `5936C07B4C0D45415F51B830B3E607724DD20A0A0823207861BFA8C4206A0825` |
+| `bypass-8-clients-5m-cycle3` | `metrics-final.prom` | 6,275 | `86F4CE43C7D700188E4BA5C076A173EDA00479322F6A3629DD5E9E57E46F0767` |
+| `bypass-8-clients-5m-cycle3` | `metrics-initial.prom` | 6,267 | `8FE20D152DC18EC62A5CC3F83B3ADE86E8EB8C86905CF0B86037DED80DD9EAB4` |
+| `bypass-8-clients-5m-cycle3` | `sessions-final.json` | 20 | `6254B38AB0F4A29C5B05C0319B3CBF2EA4F0A655F2D14B52E3D3842D9ADCD877` |
+
+## 검증 방법
+
+```powershell
+Get-FileHash -Algorithm SHA256 -LiteralPath ".\파일명"
+```
+
+저장소 접근 권한이 있는 리뷰어는 위 불변 커밋에서 파일을 내려받은 뒤 표의 크기와
+SHA-256을 재계산해 문서에 사용한 원본과 동일한지 검증할 수 있습니다. 원본은
+`results/** -text` 속성으로 줄바꿈 변환 없이 보관했습니다.
diff --git a/test-docs/test-backlog.md b/test-docs/test-backlog.md
index ccb7ada..f4634a9 100644
--- a/test-docs/test-backlog.md
+++ b/test-docs/test-backlog.md
@@ -14,6 +14,9 @@
 - [x] 맥북과 Linux 서버 간 최초 WebRTC 미디어 연결
 - [x] Python `fixed_delay 20ms` 1·2·4·6·7·8세션 5분 시험
 - [x] Windows 호스트용 Prometheus 서버 메트릭 수집기 추가
+- [x] Python `bypass` 1·2·4·8세션을 3회 반복하고 모든 실행의 동시점 서버 지표 수집
+- [x] Windows·MacBook Tailscale direct 경로와 제한된 SSH 자동화 구성
+- [x] 동일 Go 빌드의 공인 IP/NAT·Tailscale 8세션 경로 분리 진단
 
 맥북 공인 IP로 범위를 제한한 Windows 방화벽 규칙을 적용했고, `bypass` 모드에서
 30초 원격 미디어 smoke test에 성공했습니다. ICE는 `completed`, PeerConnection은
@@ -71,22 +74,34 @@
 - [x] fixed-delay JSON/CSV와 서버 수집 원본을 비공개 리소스 저장소에 업로드하고
       `artifact-manifest.md`에 불변 커밋 링크 추가
 - [ ] 6·7세션과 8세션 반복 실행에서 동시점 서버 FPS·오류율·큐·정리 지표 재수집
-- [ ] Python bypass `1 → 2 → 4 → 8` 세션 5분 기준선
-- [ ] Python bypass 조건을 반복해 편차 기록
-- [ ] 동일 REST·WebSocket·WebRTC 계약의 Go/Pion 서버 구현
+- [x] Python bypass `1 → 2 → 4 → 8` 세션 5분 기준선
+- [x] Python bypass 조건을 3회 반복해 실행 간 편차 기록
+- [x] 클라이언트·서버 시계 오프셋을 실행별 첫 연결 이벤트로 보정해 동시점 집계
+- [x] bypass 원본 108개를 비공개 리소스 저장소에 업로드하고 매니페스트에 불변 커밋 추가
+- [ ] fresh-server 반복과 30분 지속 시험으로 RSS 고수위 유지·누적 여부 구분
+- [ ] 서버 stdout을 실행별로 저장하고 VP8 decode 경고 횟수·회차 기록
+- [x] 동일 REST·WebSocket·WebRTC 계약의 Go/Pion 서버 구현
+- [x] Go RTP 재정렬·유입 큐·frame assembler 진단 계측 추가
+- [x] Go bypass 8세션 1분 Tailscale 경로 진단 통과
 - [ ] Go bypass 단일 세션 5분 기준선
 - [ ] Go fixed_delay 20ms 단일 세션 5분 기준선
+- [ ] Tailscale에서 Go bypass `1 → 2 → 4 → 8` 세션을 각 5분, 3회 반복
+- [ ] Tailscale에서 Go fixed_delay 20ms `1 → 2 → 4 → 8` 세션을 각 5분, 3회 반복
 - [ ] 양쪽의 FPS·드롭·CPU·RSS·연결 성공률 비교
 - [ ] 동일 AI 모델·정책을 적용할 수 있으면 Go real 기준선 비교
 
 AI 의미가 다르면 결과를 순수 언어 비교가 아닌 전체 구현 비교로 표시합니다.
+공인 IP/NAT 경로에서는 동일 Go 코드의 8세션 처리량이 무너졌지만 Tailscale direct
+경로에서는 세션당 28.91FPS로 통과했습니다. 따라서 언어 비교 원본은 Tailscale,
+같은 LAN 또는 통제된 TURN 경로에서만 수집하고 공인 경로 결과는 진단 자료로 분리합니다.
 
 ## 우선순위 5: 계단식·지속·스파이크 부하
 
 각 구현이 해당 모드의 단일 세션 기준선을 통과한 뒤 진행합니다.
 
 - [x] Python fixed_delay에서 `1 → 2 → 4 → 8` 세션을 각 5분 유지
-- [ ] Python bypass와 Go 구현에서 `1 → 2 → 4 → 8` 세션을 각 5분 유지
+- [x] Python bypass에서 `1 → 2 → 4 → 8` 세션을 각 5분 유지하고 3회 반복
+- [ ] Go 구현에서 Tailscale로 `1 → 2 → 4 → 8` 세션을 각 5분 유지하고 3회 반복
 - [ ] 최초 기준 위반 단계 주변을 1세션 단위로 재시험
 - [ ] 최대 안정 세션의 70~80%로 1~2시간 지속 시험
 - [ ] `0 → 최대 후보 → 0 → 최대 후보` 스파이크·재연결 시험
diff --git a/test-docs/test-plan.md b/test-docs/test-plan.md
index 98df7f9..ec81afd 100644
--- a/test-docs/test-plan.md
+++ b/test-docs/test-plan.md
@@ -416,6 +416,7 @@ WebRTC 연결이 복구되는지, 복구 후 영상과 서버 자원이 정상
 - 같은 Vision AI 서버
 - 같은 테스트 영상
 - 같은 네트워크 조건
+- 같은 시간 기준 또는 실행별 클라이언트·서버 시계 오프셋 보정 절차
 - 같은 로그 레벨
 - 같은 부하 발생기
 
diff --git a/test-docs/test-result.md b/test-docs/test-result.md
index 128fc81..68b3540 100644
--- a/test-docs/test-result.md
+++ b/test-docs/test-result.md
@@ -68,6 +68,51 @@
 단일 세션 목표 미달의 주원인입니다. bypass `py-spy`의 주요 인코딩 worker 표본에서는
 `encode`가 52.3%로 나타났으며 향후 Go/Pion bypass CPU 비교에 사용합니다.
 
+## Python bypass 다중 세션 반복 기준선
+
+2026-07-17에 하나의 Python/aiortc 서버 프로세스를 유지한 채 `1 → 2 → 4 → 8`세션을
+3회 반복했습니다. 각 실행은 5분이며 매 실행에서 클라이언트 JSON/CSV/로그와 동시점
+서버 Prometheus·CPU·RSS 지표를 모두 수집했습니다. 집계 창은 목표 세션이 전부 연결된
+시점부터 30초를 제외한 약 270초입니다. 클라이언트와 서버 호스트의 시계가 실행별로
+21.68~27.51초 어긋나 있었으므로 첫 클라이언트 연결과 서버 최초 활성 세션 표본으로
+오프셋을 보정한 뒤, 서버에서 목표 세션 수가 실제로 활성인 표본만 사용했습니다.
+
+| 동시 세션 | 통합 통과 | 클라이언트 수신 FPS 평균 ± 실행 간 표준편차 | 개별 최저 평균 FPS | 프레임 차이 평균 / 최대 | 서버 세션당 FPS 평균 ± 표준편차 | 서버 stale drop | RTT p95 최대 | 평균 CPU | 실행 평균 RSS 범위 |
+| ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
+| [1](results/bypass/1-session.md) | 3/3 | 29.40 ± 0.32 | 28.95 | 2.12% / 3.66% | 29.37 ± 0.33 | 1.30% | 18.14ms | 0.28코어 | 825.3~1,525.0MiB |
+| [2](results/bypass/2-sessions.md) | 3/3 | 29.69 ± 0.07 | 29.60 | 1.04% / 1.36% | 29.70 ± 0.07 | 0.88% | 17.12ms | 0.57코어 | 906.3~1,608.6MiB |
+| [4](results/bypass/4-sessions.md) | 3/3 | 29.90 ± 0.02 | 29.85 | 0.33% / 0.57% | 29.90 ± 0.02 | 0.30% | 47.03ms | 1.34코어 | 1,119.5~1,694.6MiB |
+| [8](results/bypass/8-sessions.md) | 3/3 | 29.70 ± 0.04 | 29.48 | 1.00% / 1.75% | 29.70 ± 0.03 | 0.97% | 71.02ms | 4.30코어 | 1,453.1~1,755.6MiB |
+
+표준편차는 3개 실행 평균의 모집단 표준편차입니다. stale drop은 3회 수신·드롭 카운터를
+합친 가중 비율입니다. 클라이언트 프레임 차이와 서버 stale drop은 관측 위치가 다르고
+일부 구간이 겹치므로 서로 더하지 않고 각각 판정했습니다. 12회 모두 연결 성공률 100%,
+서버 처리 오류 0%, 처리 큐 최댓값 0이었고 종료 후 세션 목록도 비었습니다.
+
+8세션은 평균 전체 처리량 약 237.6FPS, 세션당 29.70FPS를 유지해 5분 처리량 기준을
+3/3 통과했습니다. 따라서 **Python bypass 8세션은 반복 가능한 5분 체크포인트**입니다.
+다만 8이 시험한 최대치이고 용량 한계는 발견하지 못했으며, 30분 지속 시험을 수행하지
+않았으므로 최대 안정 세션으로 확정하지 않습니다.
+
+같은 프로세스를 유지한 결과 활성 세션과 큐는 매번 0으로 정리됐지만 RSS는 첫 1세션
+실행 평균 825.3MiB에서 마지막 8세션 실행 평균 1,755.6MiB로 증가했습니다. 마지막
+실행 최대 RSS는 1,865.5MiB였습니다. Python 메모리 할당자나 VP8 코덱 캐시의 정상적인
+고수위 유지인지, 세션별 자원 해제 누락인지는 아직 구분하지 못했으므로 fresh-server
+반복과 지속 시험으로 확인해야 합니다. 8세션 CPU는 평균 4.30코어로 세션 수보다 빠르게
+증가해 Go 비교에서 주요 차별 지표가 됩니다.
+
+서버 터미널에는 일부 `Vp8Decoder() failed to decode ... Invalid data` 경고와 연결이
+이미 닫힌 뒤 명시적 세션 삭제가 도착해 발생한 `DELETE /sessions/{id}` 404가
+관찰됐습니다. 클라이언트는 삭제 404를 멱등 성공으로 처리하고 모든 최종 세션 목록은
+비어 있었으며 처리 오류 카운터도 0이었습니다. 다만 이번 서버 stdout은 실행별 파일로
+보존하지 않았으므로 경고 횟수와 회차별 분포는 다음 시험부터 별도 수집합니다.
+
+클라이언트 원본 36개와 서버 원본 72개의 파일 크기·SHA-256은
+[bypass 원본 매니페스트](results/bypass/artifact-manifest.md)에 기록했습니다. 원본은
+비공개 [`team-framework/server-load-test-resources`](https://github.com/team-framework/server-load-test-resources/tree/69792fd4f23b5af52b18041ba2a8119da2078426/results/2026-07-17/bypass)
+저장소의 불변 커밋 `69792fd4f23b5af52b18041ba2a8119da2078426`에 보관했으며,
+업로드된 108개 파일과 로컬 원본의 SHA-256이 모두 일치합니다.
+
 ## Python fixed_delay 20ms 다중 세션 예비 용량
 
 2026-07-16~17에 동일한 Python/aiortc 코드·설정·하드웨어와 `720p30.ivf`를 사용해
@@ -140,11 +185,15 @@
 해석합니다.
 
 이 비단조 실패는 서버의 고정 용량 경계, 누적 상태, profiler 부하 또는 cooldown으로
-설명되지 않습니다. 현재 가장 가능성 높은 원인은 공인 인터넷 구간의 일시적인 WebRTC
-UDP/NAT 경로 이상입니다. 실패 원본도 세션별 상세 문서와 전체 성공률에 포함합니다.
-다만 정상 성능 수치의 평균에는 성공 실행만 포함하고, 언어별 서버 처리량 비교에서는
-통제되지 않은 네트워크 실패를 별도 표시합니다. 최종 용량 비교는 가능하면 같은 LAN
-또는 통제된 TURN 경로에서 반복합니다.
+설명되지 않습니다. 이후 동일한 Go 서버 코드를 공인 IP/NAT와 Tailscale direct 경로로
+비교한 진단에서는 공인 경로만 실패하고 Tailscale 경로가 통과했습니다. 이는 공인
+인터넷 구간의 WebRTC UDP/NAT 경로가 실제로 결과를 뒤집을 수 있음을 확인한 것입니다.
+다만 이 후속 진단이 이전 Python 실패 실행의 원인을 소급해 단정하지는 않으므로, 해당
+실행은 **공인 경로 이상과 일치하는 비통제 실패**로 분류합니다.
+
+실패 원본도 세션별 상세 문서와 전체 성공률에 포함합니다. 정상 성능 수치의 평균에는
+성공 실행만 포함하고, 언어별 서버 처리량 비교에서는 공인 경로 결과를 제외합니다.
+최종 용량 비교는 Tailscale direct, 같은 LAN 또는 통제된 TURN 경로에서 반복합니다.
 
 ### 원본 보관 및 재현성
 
@@ -233,16 +282,56 @@ Prometheus 스냅샷을 모두 저장하도록 수정했습니다.
 최적화**입니다. GPU 사용률이 평균 33.32%라 GPU 연산 포화보다는 단일 프레임 호출과
 CPU/GPU 동기화 비용의 영향이 큰 상태입니다.
 
+## Go/Pion 원격 경로 진단
+
+2026-07-17에 동일한 Go 서버 빌드와 동일한 MacBook Pion 클라이언트로 `bypass`
+8세션을 1분간 실행했습니다. 서버 코드는 Pion 수신 버퍼 확대 실험이 포함된 동일
+빌드였으므로 두 실행의 차이는 접속 경로입니다. 첫 15초를 제외한 클라이언트 표본과
+동시점 서버 카운터를 집계했습니다.
+
+| 항목 | 공인 IP/NAT | Tailscale direct |
+| --- | ---: | ---: |
+| 클라이언트 평균 수신 FPS | 5.40 | 29.88 |
+| 클라이언트 최종 프레임 차이 평균 | 70.51% | 0.66% |
+| 서버 전체 처리 FPS | 70.42 | 231.29 |
+| 서버 세션당 처리 FPS | 8.80 | 28.91 |
+| RTP 유입률 | 878.2 packet/s | 1,765.8 packet/s |
+| 최초 누락 관측 / 회복 | 70,912 / 14,970 | 207 / 207 |
+| RTP 유입 큐 drop | 0 | 0 |
+| stale decoded drop | 참고값 | 39 / 15,001 (0.26%) |
+| 연결 유지 | 8/8 | 8/8 |
+| 판정 | 실패 | 통과 |
+
+Tailscale 진단은 평균 송신 29.99FPS, 평균 수신 29.88FPS였고 클라이언트별 수신
+평균은 29.80~29.94FPS였습니다. 서버 처리 오류와 assembler discard는 0, 처리 큐
+최대값은 0이었으며 종료 후 활성 세션도 0이었습니다. 평균 프로세스 트리 CPU는
+6.48코어, 최대 RSS는 1.58GiB였습니다.
+
+같은 코드가 Tailscale direct UDP 경로에서 정상 처리량을 회복했으므로, 공인 IP 결과의
+주요 원인은 Go 언어나 FFmpeg 처리량이 아니라 **현재 공유기/NAT를 통과하는 다중
+WebRTC UDP 흐름과 Go/Pion 구현의 상호작용**입니다. 어느 NAT 동작이 원인인지는 패킷
+캡처 전까지 확정하지 않습니다. 효과가 없었던 Pion 수신 버퍼 확대 코드는 제거하고,
+RTP 재정렬·유입·조립 계측만 유지합니다.
+
+이 시험은 경로 원인 분리를 위한 1분 진단이므로 최종 Go 용량 기준선으로 사용하지
+않습니다. 다음 비교는 Tailscale 경로에서 `1 → 2 → 4 → 8` 세션을 각 5분, 3회
+반복합니다.
+
+원본 26개와 SHA-256은 비공개 리소스 저장소의 불변 커밋
+[`26e1f3044df84f7c6d3228f00201000ca35159f7`](https://github.com/team-framework/server-load-test-resources/tree/26e1f3044df84f7c6d3228f00201000ca35159f7/results/2026-07-17/go-bypass-path-diagnostic)
+에 보관합니다.
+
 ## 향후 Python/Go 비교표
 
 | 항목 | Python | Go | 차이 |
 | --- | --- | --- | --- |
 | fixed_delay 예비 체크포인트 | 클라이언트 8세션 3/3, 통합 기준 1/1 |  |  |
+| bypass 5분 체크포인트 | 8세션 통합 기준 3/3 | 8세션 1분 Tailscale 진단 통과, 5분 반복 미측정 | 최종 비교 보류 |
 | 최대 안정 세션 | 미확정 (30분 지속 시험 전) |  |  |
 | 운영 권장 세션 |  |  |  |
-| 평균 처리 FPS |  |  |  |
-| 프레임 드롭률 |  |  |  |
-| CPU 사용률 |  |  |  |
-| 메모리 사용량 |  |  |  |
+| 8세션 평균 처리 FPS | 전체 237.6 / 세션당 29.70 |  |  |
+| 8세션 프레임 드롭률 | 클라이언트 차이 1.00%, 서버 stale 0.97% |  |  |
+| 8세션 CPU 사용률 | 평균 4.30코어 |  |  |
+| 8세션 메모리 사용량 | 평균 1.55GiB, 최대 1.82GiB, 반복 중 RSS 증가 관찰 |  |  |
 | GPU 사용률 |  |  |  |
-| 한계 도달 원인 |  |  |  |
+| 한계 도달 원인 | 8세션까지 처리량 한계 미도달, CPU 비선형 증가·RSS 유지 관찰 |  |  |
diff --git a/test-docs/test-runbook.md b/test-docs/test-runbook.md
index f113567..1337775 100644
--- a/test-docs/test-runbook.md
+++ b/test-docs/test-runbook.md
@@ -80,6 +80,32 @@ It also waits up to 10 seconds for the selected mode's received/processed frame
 series. Missing required metrics stop the collection instead of being recorded
 as zero; only absent drop/failure counter series are treated as zero.
 
+### Cross-host clock alignment
+
+Do not join Mac Pion timestamps and Windows collector timestamps directly unless
+both hosts have first been checked against the same time source. The 2026-07-17
+bypass run observed a 21.68 to 27.51 second offset that changed during the test.
+An uncorrected join included post-disconnect zero-session samples and falsely
+reduced server FPS.
+
+Prefer synchronizing both hosts before a run. When that is not available, align
+each run independently:
+
+1. Read the first `client=... connected` timestamp from the Pion log.
+2. Read the first `app.csv` row where `active_sessions > 0`.
+3. Use their difference as that run's client-to-server clock offset.
+4. Start the stable client window 30 seconds after the last target client connects.
+5. Translate that window by the offset and use only server rows whose
+   `active_sessions` equals the target client count.
+
+`loadtest/scripts/analyze_bypass_runs.py` applies this rule and rejects an
+incomplete set of client or server artifacts.
+
+Capture server stdout/stderr to a per-run log as well as Prometheus data. The
+Prometheus failure counter does not include codec warnings such as VP8 packets
+that the decoder skips, and cleanup-related HTTP responses are otherwise lost
+when the interactive terminal closes.
+
 Use `client pass` only for FPS, frame-gap, and connection checks derived from the
 Pion result. Use `combined pass` only when the same run also captures server FPS,
 stale drop, failure rate, queue behavior, and cleanup. A client-only pass must not