diff --git a/.env.example b/.env.example
index a8ada78..a06739a 100644
--- a/.env.example
+++ b/.env.example
@@ -2,7 +2,7 @@ APP_NAME=inno-live-server
 APP_ENV=local
 DATABASE_URL=postgresql+asyncpg://postgres:postgres@localhost:5432/inno_live_server
 WEBRTC_STUN_URLS=stun:stun.l.google.com:19302
-WEBRTC_TURN_URLS=
+WEBRTC_TURN_URLS=turn:innolive.duckdns.org:3478?transport=udp,turn:innolive.duckdns.org:3478?transport=tcp,turns:innolive.duckdns.org:5349?transport=tcp
 WEBRTC_TURN_USERNAME=
 WEBRTC_TURN_CREDENTIAL=
 WEBRTC_ANNOUNCED_IP=
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/README.md b/README.md
index 8bff028..bf5fb68 100644
--- a/README.md
+++ b/README.md
@@ -219,7 +219,7 @@ Configure the server with environment variables:
 
 ```bash
 WEBRTC_STUN_URLS=stun:stun.l.google.com:19302
-WEBRTC_TURN_URLS=turn:turn.example.com:3478?transport=udp
+WEBRTC_TURN_URLS=turn:innolive.duckdns.org:3478?transport=udp,turn:innolive.duckdns.org:3478?transport=tcp,turns:innolive.duckdns.org:5349?transport=tcp
 WEBRTC_TURN_USERNAME=
 WEBRTC_TURN_CREDENTIAL=
 WEBRTC_ANNOUNCED_IP=
diff --git a/SERVER_STRUCTURE.md b/SERVER_STRUCTURE.md
index c80f73a..4b5e2f4 100644
--- a/SERVER_STRUCTURE.md
+++ b/SERVER_STRUCTURE.md
@@ -160,7 +160,7 @@ Status: active → closing → closed
 | 설정 | 기본값 | 설명 |
 |------|--------|------|
 | `webrtc_stun_urls` | `stun:stun.l.google.com:19302` | STUN 서버 URL |
-| `webrtc_turn_urls` | (비어있음) | TURN 서버 URL (선택사항) |
+| `webrtc_turn_urls` | `turn:innolive.duckdns.org:3478?transport=udp`, `turn:innolive.duckdns.org:3478?transport=tcp`, `turns:innolive.duckdns.org:5349?transport=tcp` | TURN UDP/TCP/TLS 서버 URL |
 | `webrtc_turn_username` | null | TURN 인증 사용자명 |
 | `webrtc_turn_credential` | null | TURN 인증 자격증명 |
 | `webrtc_announced_ip` | null | 호스트 candidate IP 교체용 공개 IP |
diff --git a/app/core/config.py b/app/core/config.py
index 083b692..35b71f6 100644
--- a/app/core/config.py
+++ b/app/core/config.py
@@ -10,7 +10,11 @@ class Settings(BaseSettings):
     app_env: str = "local"
     log_level: str = "INFO"
     webrtc_stun_urls: str = "stun:stun.l.google.com:19302"
-    webrtc_turn_urls: str = ""
+    webrtc_turn_urls: str = (
+        "turn:innolive.duckdns.org:3478?transport=udp,"
+        "turn:innolive.duckdns.org:3478?transport=tcp,"
+        "turns:innolive.duckdns.org:5349?transport=tcp"
+    )
     webrtc_turn_username: str | None = None
     webrtc_turn_credential: str | None = None
     webrtc_announced_ip: str | None = None
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/software_engineering_portfolio.md b/software_engineering_portfolio.md
new file mode 100644
index 0000000..081abe9
--- /dev/null
+++ b/software_engineering_portfolio.md
@@ -0,0 +1,170 @@
+# 소프트웨어공학실무 포트폴리오
+
+## 1. 요구 분석 프로젝트
+
+### 제목
+
+요구 분석 프로젝트
+
+### 프로젝트 개요
+
+이번 요구 분석 프로젝트에서는 주문 및 배달 서비스 문제를 선택하고, 가상의 서비스인 **배달의정석**을 대상으로 요구사항을 분석했다. 서비스의 기본 목표는 소비자가 주변 음식점을 쉽게 찾고 주문할 수 있게 하며, 점주는 주문과 홍보 기회를 얻고, 배달 수행원은 배달 위치와 경로를 효율적으로 확인할 수 있게 하는 것이다.
+
+이 프로젝트를 진행하면서 단순히 "음식 주문 앱을 만든다"는 수준에서 멈추지 않고, 실제 시스템에 영향을 주는 사용자와 이해관계자를 나누어 보았다. 이를 통해 같은 서비스라도 소비자, 점주, 배달 수행원, 운영사 담당자가 서로 다른 관점과 요구를 가진다는 점을 확인할 수 있었다.
+
+### 이해관계자 분석
+
+| 구분 | 분석 내용 |
+|---|---|
+| 소비자 분쟁 담당자 | 음식 품질, 오배송, 주문 누락 같은 문제가 발생했을 때 소비자와 음식점 사이의 분쟁을 처리하는 역할이다. 이 담당자에게는 주문 기록, 음식점 정보, 소비자 요청 내역이 정확히 연결되는 것이 중요하다. |
+| 마케팅 담당자 | 신규 고객 유입과 이벤트 기획을 담당한다. 서비스의 음식점 노출 방식, 할인 정책, 사용자 유입 경로는 마케팅 성과와 직접 연결된다. |
+| 배달 수행원 | 음식점에서 소비자에게 음식을 전달하는 과정에 참여한다. 주소 확인, 경로 확인, 주문 취소 알림 같은 기능이 부족하면 배달 시간이 늘어나고 서비스 만족도도 낮아질 수 있다. |
+
+### 관련 개념과 보완점
+
+이해관계자는 시스템의 개발과 운영 결과에 영향을 받거나 영향을 주는 사람 또는 조직이다. 반면 사용자는 시스템을 직접 조작하는 사람이고, 유스케이스 다이어그램의 액터는 시스템과 상호작용하는 외부 역할을 의미한다.
+
+보고서에서는 배달 수행원을 이해관계자로도 다루고 유스케이스 다이어그램의 액터로도 표현했다. 이 부분은 논리적으로 가능하지만, 포트폴리오에서는 **배달 수행원은 서비스 품질에 영향을 받는 이해관계자이면서 동시에 배달 관련 기능을 사용하는 액터**라고 구분해 설명하는 것이 더 정확하다.
+
+### 기능 요구사항 정리
+
+| 요구사항 | 포트폴리오용 정리 |
+|---|---|
+| 근처 음식점 조회 | 시스템은 소비자의 현재 위치나 입력 주소를 기준으로 주문 가능한 주변 음식점 목록을 제공해야 한다. |
+| 주문 현황 확인 | 점주는 접수된 주문의 상태를 실시간으로 확인하고, 조리 가능 여부에 따라 주문을 처리할 수 있어야 한다. |
+| 배달 위치 확인 | 배달 수행원은 음식점 위치, 소비자 위치, 배달 경로를 지도에서 확인할 수 있어야 한다. |
+
+기능 요구사항은 시스템이 반드시 제공해야 하는 동작을 문장으로 정리한 것이다. 좋은 기능 요구사항은 주체, 기능, 결과가 분명하고 나중에 테스트할 수 있어야 한다. 예를 들어 "주문 현황을 확인한다"보다 "점주는 접수, 조리 중, 완료, 거절 상태로 구분된 주문 현황을 확인할 수 있어야 한다"라고 쓰면 구현 범위와 검증 기준이 더 명확해진다.
+
+### 유스케이스 모델링 정리
+
+유스케이스 다이어그램에서는 소비자, 점주, 배달 수행원을 주요 액터로 설정했다. 소비자는 근처 음식점 조회, 주문하기, 주문 취소 기능과 연결되고, 점주는 주문 현황 확인과 주문 거절 기능을 사용한다. 배달 수행원은 배달하기와 배달 경로 확인 기능을 사용한다.
+
+| 액터 | 주요 유스케이스 |
+|---|---|
+| 소비자 | 근처 음식점 조회, 주문하기, 주문 취소 |
+| 점주 | 주문 현황 확인, 주문 거절 |
+| 배달 수행원 | 배달하기, 배달 경로 확인 |
+
+유스케이스 관계에서는 `<<include>>`와 `<<extend>>`의 의미를 구분하는 것이 중요했다. `<<include>>`는 기본 유스케이스가 항상 포함하는 공통 기능에 사용하고, `<<extend>>`는 특정 조건에서만 추가되는 기능에 사용한다. 따라서 멤버십 할인이 주문 과정에서 조건부로 적용된다면 `주문하기`를 확장하는 관계로 보는 것이 적절하다. 반면 위약금 결제는 모든 주문 취소에서 항상 발생하는 것이 아니라 취소 시점이나 정책에 따라 달라질 수 있으므로, 실제 서비스라면 `주문 취소`의 필수 포함 기능으로 단정하기보다 조건부 확장 흐름으로 다루는 것이 더 자연스럽다.
+
+### 유스케이스 명세 보완
+
+보고서에서는 `주문하기` 유스케이스를 선택해 기본 흐름과 대안 흐름을 작성했다. 포트폴리오 관점에서 보면 이 명세는 소비자가 음식점을 선택하고 메뉴를 고른 뒤 주문 요청을 저장하는 흐름을 잘 보여준다. 다만 실제 주문 서비스에서는 주문 요청이 단순히 소비자의 목록에 저장되는 것에서 끝나지 않고, 점주에게 전달되어 주문 상태가 변경되어야 한다.
+
+따라서 종료 조건은 다음과 같이 보완할 수 있다.
+
+> 소비자의 주문 요청이 저장되고, 해당 주문이 점주에게 전달되어 `접수 대기` 상태로 등록된다.
+
+이렇게 수정하면 유스케이스의 결과가 소비자 화면뿐 아니라 점주 업무 흐름까지 연결되므로, 시스템의 실제 동작을 더 정확하게 설명할 수 있다.
+
+## 2. 소프트웨어 개발 프로세스 반복적 모델 분석
+
+### 제목
+
+소프트웨어 개발 프로세스 반복적 모델 분석
+
+### 보고서 요약
+
+반복적 모델은 소프트웨어를 한 번의 순차적인 과정으로 완성하는 방식이 아니라, 분석, 설계, 구현, 테스트, 피드백 과정을 여러 차례 반복하면서 완성도를 높이는 개발 프로세스이다. 이 모델은 사용자의 요구가 개발 중에 더 구체화될 수 있다는 점을 전제로 하며, 초기 결과물을 바탕으로 문제를 발견하고 다음 반복에서 개선하는 데 강점이 있다.
+
+반복적 모델은 대표적으로 **증분형 모델**과 **진화형 모델**로 나누어 볼 수 있다.
+
+| 모델 | 핵심 내용 | 적합한 상황 |
+|---|---|---|
+| 증분형 모델 | 전체 기능을 여러 부분으로 나누고, 각 부분을 분석, 설계, 구현, 테스트하여 단계적으로 완성한다. | 최종 목표와 주요 요구사항이 어느 정도 정해져 있지만, 기능을 나누어 순차적으로 제공하고 싶을 때 적합하다. |
+| 진화형 모델 | 초기 프로토타입을 만들고 사용자 피드백을 반영하면서 요구사항과 제품을 함께 발전시킨다. | 요구사항이 명확하지 않거나 개발 중 변경 가능성이 큰 경우에 적합하다. |
+
+증분형 모델과 진화형 모델은 모두 반복을 활용하지만 초점이 다르다. 증분형 모델은 정해진 목표를 여러 기능 단위로 나누어 완성하는 데 초점이 있고, 진화형 모델은 불명확한 요구사항을 실제 사용자의 반응을 통해 구체화하는 데 초점이 있다.
+
+### 특징과 장단점
+
+| 구분 | 정리 |
+|---|---|
+| 특징 | 전체 시스템을 한 번에 완성하지 않고, 일부 기능 또는 일부 범위를 반복적으로 개발한다. 각 반복에서는 분석, 설계, 구현, 테스트가 다시 수행된다. |
+| 장점 | 중간 결과물을 빠르게 확인할 수 있고, 사용자 피드백이나 요구사항 변경을 다음 반복에 반영할 수 있다. 따라서 문제를 비교적 이른 시점에 발견하고 수정할 수 있다. |
+| 단점 | 반복이 많아질수록 버전과 산출물 관리가 어려워질 수 있다. 또한 변경을 계속 반영하면서 구조 관리가 부족하면 시스템이 복잡해지고 유지보수가 어려워질 수 있다. |
+
+### 문항 1
+
+다음 중 반복적 모델에 대한 설명으로 가장 적절한 것은?
+
+1. 증분형 모델은 요구사항이 거의 정해지지 않은 상황에서 가장 적합하다.
+2. 반복적 모델은 여러 산출물을 만든 뒤 가장 좋은 하나만 선택하는 방식이다.
+3. 진화형 모델은 전체 진화 방향에 대한 개요를 가지고 피드백을 반영하며 발전시킨다.
+4. 증분형 모델은 항상 프로토타입을 먼저 만들고 요구사항을 새로 정의하는 방식이다.
+
+정답: 3
+
+풀이: 진화형 모델은 초기 요구사항이 불명확할 때 프로토타입과 피드백을 통해 제품을 발전시키는 방식이지만, 아무 방향 없이 개발하는 것은 아니다. 전체적인 목표나 진화 방향에 대한 개요는 필요하다. 1번은 진화형 모델에 더 가까운 설명이고, 2번은 반복적 모델의 목적을 잘못 이해한 것이다. 4번은 증분형 모델보다 진화형 모델의 특징에 가깝다.
+
+### 문항 2
+
+다음 상황에 가장 알맞은 개발 프로세스 모델은?
+
+> 개발팀은 "직장인 대상 건강관리 서비스"라는 큰 주제만 전달받았고, 세부 기능과 화면 요구사항은 아직 정리되지 않았다. 우선 핵심 기능을 담은 프로토타입을 만든 뒤, 고객 미팅과 시범 운영을 거치며 요구사항을 계속 추가하고 수정할 계획이다.
+
+1. 증분형 모델
+2. 진화형 모델
+3. 폭포수 모델
+4. V 모델
+
+정답: 2
+
+풀이: 이 상황은 요구사항이 명확하지 않고, 프로토타입을 통해 사용자의 반응을 확인하면서 제품을 발전시키는 구조이다. 따라서 진화형 모델이 가장 적합하다. 폭포수 모델과 V 모델은 요구사항이 초기에 비교적 안정적으로 정리되어 있을 때 더 적합하며, 증분형 모델은 목표 기능이 어느 정도 정해진 상태에서 기능을 나누어 개발하는 방식에 가깝다.
+
+## 3. 소프트웨어공학 용어와 개발 프로젝트 연결하기
+
+### 연결한 개발 프로젝트
+
+| 항목 | 내용 |
+|---|---|
+| 프로젝트명 | inno-live-server |
+| 프로젝트 성격 | FastAPI 기반 실시간 라이브 스트리밍 서버 |
+| 주요 기능 | WebRTC 세션 생성, WebSocket 시그널링, AI 얼굴 블러 처리, 기준 얼굴 등록, RTMP 송출, 상태 확인 API |
+| 참고한 코드 구조 | `app/api/routes/`, `app/services/`, `app/core/config.py`, `privacy_blur/`, `tests/` |
+
+`inno-live-server`는 브라우저에서 들어온 실시간 영상 트랙을 서버가 받아 AI 프라이버시 필터를 적용하고, 처리된 영상을 다시 송출하는 서버 프로젝트이다. 이 프로젝트는 단순한 CRUD 애플리케이션보다 실시간성, 개인정보 보호, 장애 대응이 중요하기 때문에 소프트웨어공학 개념을 실제 코드 구조와 연결해 보기 좋다.
+
+### 용어 1: 결합도(Coupling)
+
+| 항목 | 내용 |
+|---|---|
+| 의미 | 결합도는 모듈이나 클래스가 서로 얼마나 의존하고 있는지를 나타내는 개념이다. 결합도가 낮으면 한 부분을 수정해도 다른 부분에 미치는 영향이 작아지고, 테스트와 유지보수가 쉬워진다. |
+| 프로젝트 적용 | 이 프로젝트는 API 라우터, 세션 관리, WebRTC 처리, AI 필터 처리를 별도 계층으로 나누어 결합도를 낮추려는 구조를 가지고 있다. 예를 들어 `app/api/routes/webrtc.py`는 WebSocket 메시지를 받고 요청을 검증한 뒤, 실제 offer 처리와 ICE candidate 처리는 `OfferService`, `IceCandidateService`에 위임한다. `app/api/routes/sessions.py`도 직접 세션 저장 구조를 조작하지 않고 `SessionManager`를 통해 세션을 생성하고 조회한다. |
+| 코드 근거 | `app/services/webrtc/offer.py`는 WebRTC answer 생성에 집중하고, `app/services/sessions/manager.py`는 세션 상태와 트랙 수명주기를 관리한다. AI 필터 생성과 런타임 관리는 `app/services/ai/filter.py`, 실제 영상 프레임 보호 처리는 `app/services/ai/track.py`에 분리되어 있다. |
+| 논리적 평가 | 라우터가 AI 모델 내부 구조나 WebRTC 세부 구현을 직접 알지 않아도 되므로 전체적으로 결합도를 낮추는 방향의 설계라고 볼 수 있다. 다만 `ProtectedVideoTrack.stop()`에서 `app.services.ai.filter`의 내부 전역 목록에 접근하는 부분처럼 일부 구현은 내부 상태에 직접 의존한다. 이 부분은 장기적으로 명시적인 필터 등록/해제 인터페이스로 바꾸면 결합도를 더 낮출 수 있다. |
+
+### 용어 2: 응집도(Cohesion)
+
+| 항목 | 내용 |
+|---|---|
+| 의미 | 응집도는 하나의 모듈 안에 있는 기능들이 하나의 목적을 위해 얼마나 밀접하게 모여 있는지를 의미한다. 응집도가 높으면 모듈의 책임이 분명해지고 코드를 이해하기 쉬워진다. |
+| 프로젝트 적용 | 프로젝트의 디렉터리 구조를 보면 `app/api/routes/`는 외부 요청 처리, `app/services/webrtc/`는 WebRTC 연결과 SDP/ICE 처리, `app/services/ai/`는 AI 프라이버시 필터, `app/core/`는 설정과 예외 처리처럼 역할이 나뉘어 있다. |
+| 코드 근거 | `ProtectedVideoTrack`은 원본 영상 프레임을 받아 AI 필터를 적용하고, 실패하면 검은 프레임을 반환하는 "보호된 영상 트랙" 책임에 집중한다. `app/core/config.py`는 환경 변수 기반 설정을 모아 WebRTC, AI, RTMP 설정을 한곳에서 관리한다. |
+| 논리적 평가 | 기능별 파일과 패키지가 비교적 명확해 응집도가 높은 편이다. 특히 AI 필터 실패 시 원본 영상을 노출하지 않는 정책은 `ProtectedVideoTrack` 안에서 일관되게 처리된다. 다만 `SessionManager`는 세션 생성, 트랙 교체, 연결 종료 처리, RTMP 송출 시작/중지까지 담당하므로 프로젝트가 더 커지면 스트리밍 송출 책임을 별도 서비스로 분리하는 것이 응집도 측면에서 더 좋다. |
+
+### 용어 3: CMMI 모델의 조직 성숙도
+
+| 항목 | 내용 |
+|---|---|
+| 의미 | CMMI는 조직의 소프트웨어 개발 프로세스가 얼마나 체계적으로 관리되고 개선되는지를 평가하는 성숙도 모델이다. 일반적으로 초기 단계인 1단계부터 관리, 정의, 정량적 관리, 지속적 개선 단계로 성숙도가 높아진다. |
+| 프로젝트 적용 | `inno-live-server`는 개인 또는 소규모 프로젝트이므로 CMMI 성숙도 등급을 공식적으로 부여할 수는 없다. 다만 프로젝트 산출물을 기준으로 보면 요구사항과 실행 방법을 `README.md`에 정리하고, 서버 구조를 `SERVER_STRUCTURE.md`에 문서화했으며, 기능별 테스트를 `tests/`에 작성했다. 이는 즉흥적으로만 개발하는 1단계보다, 프로젝트 단위로 작업을 관리하고 검증하려는 2단계적 특징에 가깝다. |
+| 코드와 산출물 근거 | `.env.example`, `Dockerfile`, `docker-compose.prod.yml`은 실행 환경을 표준화하려는 산출물이고, `tests/test_track.py`, `tests/test_api_webrtc.py`, `tests/test_session_manager.py` 등은 기능 변경 시 회귀를 확인하기 위한 검증 장치이다. 또한 `SERVER_STRUCTURE.md`와 `AI_ARCHITECTURE.md`는 구조와 설계 의도를 문서화한다. |
+| 논리적 평가 | 이 프로젝트는 프로젝트 수준의 관리와 검증 체계는 갖추고 있지만, 조직 전체에 공통 적용되는 표준 프로세스나 정량적 품질 관리 지표가 충분히 정의되어 있다고 보기는 어렵다. 따라서 "CMMI 3단계 이상"이라고 단정하는 것은 과장이다. 포트폴리오에서는 **CMMI 관점에서 보면 프로젝트 단위 관리 수준은 갖추었지만, 조직 차원의 표준화와 정량적 개선 체계는 앞으로 보완할 부분**이라고 설명하는 것이 가장 정확하다. |
+| 개선 방향 | 이슈 관리 규칙, 코드 리뷰 기준, 배포 전 체크리스트, 장애 기록 방식, 성능 지표 추적 기준을 문서화하면 조직 성숙도 관점에서 더 높은 단계로 발전할 수 있다. |
+
+### 용어 4: 비기능 요구사항(Non-Functional Requirement)
+
+| 항목 | 내용 |
+|---|---|
+| 의미 | 비기능 요구사항은 시스템이 어떤 기능을 제공하는지를 넘어서, 그 기능을 어떤 품질 수준으로 제공해야 하는지를 설명한다. 성능, 보안, 신뢰성, 가용성, 개인정보 보호 등이 포함된다. |
+| 프로젝트 적용 | 이 프로젝트의 핵심 비기능 요구사항은 실시간성, 개인정보 보호, 신뢰성이다. 영상 처리 지연이 너무 길면 라이브 스트리밍으로 사용하기 어렵고, AI 필터 실패 시 원본 얼굴이 그대로 노출되면 개인정보 보호 목적을 달성할 수 없다. |
+| 코드 근거 | `app/services/ai/track.py`의 `ProtectedVideoTrack`은 AI 필터가 실패하거나 시간 초과될 때 원본 프레임을 그대로 보내지 않고 검은 프레임을 반환한다. 이는 기능을 계속 제공하는 것보다 개인정보 노출을 막는 것을 우선한 설계이다. 또한 `app/core/config.py`에는 AI 배치 크기, 프레임 타임아웃, WebRTC UDP 포트 범위, RTMP 재시도 설정이 환경 변수로 분리되어 있어 운영 환경에 맞게 품질 속성을 조정할 수 있다. |
+| 논리적 평가 | 이 설계는 "영상은 계속 나가야 한다"는 기능 요구사항과 "개인정보를 보호해야 한다"는 비기능 요구사항이 충돌할 때, 개인정보 보호를 우선하도록 만든 사례이다. 따라서 단순 기능 구현이 아니라 품질 요구사항을 코드 정책으로 반영한 사례라고 볼 수 있다. |
+
+### 종합 정리
+
+`inno-live-server` 프로젝트를 소프트웨어공학 개념으로 분석해 보면, 기능을 단순히 구현하는 것보다 구조와 품질을 함께 고려한 프로젝트라는 점을 확인할 수 있다. API 라우터와 서비스 계층을 나누어 결합도를 낮추려 했고, WebRTC, AI 필터, 설정, 테스트를 역할별로 나누어 응집도를 높였다. 또한 AI 필터 실패 시 원본 영상을 차단하는 방식은 개인정보 보호라는 비기능 요구사항을 코드에 직접 반영한 사례이다.
+
+CMMI 모델의 조직 성숙도 관점에서는 이 프로젝트가 공식적인 조직 프로세스를 갖춘 것은 아니지만, 문서화, 테스트, 실행 환경 표준화가 존재한다는 점에서 프로젝트 단위의 관리 체계는 확인할 수 있다. 앞으로 코드 리뷰 기준, 배포 체크리스트, 성능 지표 관리까지 체계화한다면 더 성숙한 개발 프로세스로 발전할 수 있다.
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
diff --git a/tests/test_webrtc_ice_config.py b/tests/test_webrtc_ice_config.py
index 8f386e3..5eeb48b 100644
--- a/tests/test_webrtc_ice_config.py
+++ b/tests/test_webrtc_ice_config.py
@@ -4,6 +4,27 @@
 from app.services.webrtc.sdp import extract_ice_candidates, rewrite_host_candidates
 
 
+def test_webrtc_config_exposes_default_stun_and_turn_servers():
+    from app.main import app
+
+    with TestClient(app) as client:
+        response = client.get("/webrtc/config")
+
+    assert response.status_code == 200
+    assert response.json() == {
+        "iceServers": [
+            {"urls": ["stun:stun.l.google.com:19302"]},
+            {
+                "urls": [
+                    "turn:innolive.duckdns.org:3478?transport=udp",
+                    "turn:innolive.duckdns.org:3478?transport=tcp",
+                    "turns:innolive.duckdns.org:5349?transport=tcp",
+                ],
+            },
+        ],
+    }
+
+
 def test_webrtc_config_exposes_stun_and_turn_from_environment(monkeypatch):
     monkeypatch.setenv("WEBRTC_STUN_URLS", "stun:stun1.example.com:3478")
     monkeypatch.setenv(