diff --git a/.clue/id-ledger.yaml b/.clue/id-ledger.yaml
index c6d6c0aa..7c7ba7a2 100644
--- a/.clue/id-ledger.yaml
+++ b/.clue/id-ledger.yaml
@@ -228,6 +228,24 @@ events:
     - {id: M-003, kind: numeric, state: retired, prefix: M, component: "3"}
     - {id: M-004, kind: numeric, state: retired, prefix: M, component: "4"}
     - {id: M-130, kind: numeric, state: retired, prefix: M, component: "130"}
+    - {id: CH-018, kind: numeric, state: reserved, prefix: CH, component: "18"}
+    - {id: HARN-002, kind: numeric, state: reserved, prefix: HARN, component: "2"}
+    - {id: HARN-003, kind: numeric, state: reserved, prefix: HARN, component: "3"}
+    - {id: HARN-004, kind: numeric, state: reserved, prefix: HARN, component: "4"}
+    - {id: HARN-005, kind: numeric, state: reserved, prefix: HARN, component: "5"}
+    - {id: HARN-006, kind: numeric, state: reserved, prefix: HARN, component: "6"}
+    - {id: HARN-007, kind: numeric, state: reserved, prefix: HARN, component: "7"}
+    - {id: HARN-008, kind: numeric, state: reserved, prefix: HARN, component: "8"}
+    - {id: M-148, kind: numeric, state: reserved, prefix: M, component: "148"}
+    - {id: AN-016, kind: numeric, state: reserved, prefix: AN, component: "16"}
+    - {id: AN-017, kind: numeric, state: reserved, prefix: AN, component: "17"}
+    - {id: TASKS-011, kind: numeric, state: reserved, prefix: TASKS, component: "11"}
+    - {id: OQ-009, kind: numeric, state: reserved, prefix: OQ, component: "9"}
+    - {id: CH-018, kind: numeric, state: live, prefix: CH, component: "18"}
+    - {id: HARN-008, kind: numeric, state: live, prefix: HARN, component: "8"}
+    - {id: M-148, kind: numeric, state: live, prefix: M, component: "148"}
+    - {id: AN-016, kind: numeric, state: live, prefix: AN, component: "16"}
+    - {id: TASKS-011, kind: numeric, state: live, prefix: TASKS, component: "11"}
 high-water:
     - {id: ADR-002, kind: numeric, state: reserved, prefix: ADR, component: "2"}
     - {id: AN-014, kind: numeric, state: reserved, prefix: AN, component: "14"}
diff --git a/compat-test/README.md b/compat-test/README.md
index 507c2101..66b2b6bd 100644
--- a/compat-test/README.md
+++ b/compat-test/README.md
@@ -204,6 +204,18 @@ Full error details land in `errors/robocode/<robot>.log` and
 
 `parity-registry.json` is the tracked evidence carrier. It appends each subject observation with the exact jar identity, setup, engine artifacts, normalized errors, and focused retest link. Normalized error origins skip engine implementation frames from both classic and the bridge so the first legacy application frame remains comparable across engines. It also retains an append-only diagnosis history, so a later triage decision cannot rewrite an earlier one. `parity-registry.md` renders the current status of every subject for review. Import an existing checkpoint with `--sync-registry`; after a diagnosis, tag a case with `--set-cause <subject> <cause> <owner>` and rerun that cause with `--retest-cause <cause> --repair <commit-or-PR>`.
 
+### Skipped-turn telemetry
+
+Pass `--capture-skipped-turns` to enable opt-in records for Tank Royale bridge callbacks; capture is off by default. Each registry observation stores `tank_royale.skipped_turn_telemetry` with a status and, only when capture is complete, an `events` list of unique `{bot_id, round, turn}` values sorted by round and turn, including warm-up. `disabled`, `unavailable`, and `incomplete` use `events: null`; `captured` with `events: []` means the completed run delivered no skipped-turn callbacks to the bridge. Per-bot readiness and completion-count markers let the harness detect an older bridge jar or a truncated capture. The data describes callbacks delivered to the bridge and does not claim to record server detections that never reach it.
+
+Use the conformance probe to check a forced-skip run locally:
+
+```bash
+python compat_test.py --conformance conformance-robots --conformance-source conformance-robots/conformance/probes/SkippedTurnProbe.java --robot-class conformance.probes.SkippedTurnProbe --engine tr --rounds 1 --capture-skipped-turns
+```
+
+The conformance JSON includes `skipped_turn_telemetry` at the top level. On a parity sweep, use `--capture-skipped-turns` and inspect the per-observation field in `parity-registry.json`. Repeated `--confirm-score` runs keep one record per attempt under `confirmation.skipped_turn_telemetry_runs`; the regression gate prints the same per-attempt JSON to stdout.
+
 **Every row states the setup it was measured at.** The report is regenerated from the state
 file long after the battles ran, so a single header describing the current configuration
 would restate every stored row as though it had been measured under today's settings --
diff --git a/compat-test/compat_test.py b/compat-test/compat_test.py
index b7c81aba..470981b4 100644
--- a/compat-test/compat_test.py
+++ b/compat-test/compat_test.py
@@ -58,6 +58,12 @@
 
 BASE_DIR = Path(__file__).resolve().parent
 TANK_ROYALE_HOME = Path(os.environ.get("COMPAT_TANK_ROYALE_HOME", r"C:\Code\tank-royale"))
+SKIPPED_TURN_TELEMETRY_PROPERTY = "robocode.bridge.skippedTurnTelemetry"
+SKIPPED_TURN_READY_RE = re.compile(r"^BRIDGE_SKIPPED_TURN_TELEMETRY_READY botId=(\d+)\s*$")
+SKIPPED_TURN_EVENT_RE = re.compile(
+    r"^BRIDGE_SKIPPED_TURN botId=(\d+) round=(\d+) turn=(\d+)\s*$")
+SKIPPED_TURN_COMPLETE_RE = re.compile(
+    r"^BRIDGE_SKIPPED_TURN_TELEMETRY_COMPLETE botId=(\d+) eventCount=(\d+)\s*$")
 
 
 def local_bot_api_jar():
@@ -404,7 +410,7 @@ def kill_process_tree(proc: subprocess.Popen, diagnostics=None):
     return proc.poll() is not None
 
 
-def run_java(cmd, cwd, timeout, abort_when=None, poll_seconds=2.0):
+def run_java(cmd, cwd, timeout, abort_when=None, poll_seconds=2.0, env=None):
     """Runs a java command; returns (returncode, stdout+stderr, timed_out).
 
     `abort_when` is an optional callable polled while the battle runs. When it returns
@@ -416,7 +422,7 @@ def run_java(cmd, cwd, timeout, abort_when=None, poll_seconds=2.0):
     harness rather than the battle."""
     proc = subprocess.Popen(
         cmd, cwd=str(cwd), stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
-        text=True, encoding="utf-8", errors="replace")
+        text=True, encoding="utf-8", errors="replace", env=env)
 
     chunks = []
     reader = threading.Thread(target=_drain, args=(proc.stdout, chunks), daemon=True)
@@ -741,7 +747,7 @@ def run_rc_battle(jar_path: Path, classname, version, opts, setup,
 
 def summarize_worker_result(out_file, returncode, output, timed_out, elapsed, engine):
     result = {
-        "ok": False, "score": None, "scores": [], "errors": [],
+        "ok": False, "completed": False, "score": None, "scores": [], "errors": [],
         "error_count": 0, "elapsed": round(elapsed, 1), "log_text": "",
     }
     cleanup_failures = []
@@ -773,6 +779,7 @@ def summarize_worker_result(out_file, returncode, output, timed_out, elapsed, en
         return result
 
     result["ok"] = bool(data.get("ok"))
+    result["completed"] = bool(data.get("completed"))
     result["selected"] = data.get("selected")
     scores = [p.get("score", 0) for p in data.get("participants", [])]
     result["scores"] = [round(float(s), 1) for s in scores]
@@ -922,6 +929,83 @@ def staged_log_dirs(bot_dirs):
     return list(dict.fromkeys(expanded))
 
 
+def skipped_turn_telemetry(bot_dirs, enabled, completed, expected_bots):
+    """Reads the opt-in bridge markers without treating a missing marker as zero skips."""
+    if not enabled:
+        return {"status": "disabled", "events": None}
+    if not completed:
+        return {"status": "incomplete", "events": None}
+
+    ready_bot_ids = set()
+    completed_event_counts = {}
+    events = set()
+    directories = staged_log_dirs(bot_dirs)
+    if not directories:
+        return {"status": "incomplete", "events": None}
+
+    for directory in directories:
+        try:
+            with open(directory / "stdout.log", encoding="utf-8", errors="replace") as log:
+                for line in log:
+                    line = line.rstrip("\r\n")
+                    ready_match = SKIPPED_TURN_READY_RE.fullmatch(line)
+                    if ready_match:
+                        ready_bot_ids.add(int(ready_match.group(1)))
+                        continue
+                    complete_match = SKIPPED_TURN_COMPLETE_RE.fullmatch(line)
+                    if complete_match:
+                        bot_id, event_count = (int(value) for value in complete_match.groups())
+                        if bot_id in completed_event_counts:
+                            return {"status": "incomplete", "events": None}
+                        completed_event_counts[bot_id] = event_count
+                        continue
+                    event_match = SKIPPED_TURN_EVENT_RE.fullmatch(line)
+                    if event_match:
+                        events.add(tuple(int(value) for value in event_match.groups()))
+        except OSError:
+            return {"status": "incomplete", "events": None}
+
+    if expected_bots < 1 or len(ready_bot_ids) != expected_bots:
+        return {"status": "unavailable", "events": None}
+
+    if any(bot_id not in ready_bot_ids for bot_id, _, _ in events):
+        return {"status": "unavailable", "events": None}
+
+    if set(completed_event_counts) != ready_bot_ids:
+        return {"status": "incomplete", "events": None}
+
+    events_by_bot = {}
+    for bot_id, _, _ in events:
+        events_by_bot[bot_id] = events_by_bot.get(bot_id, 0) + 1
+    if any(completed_event_counts[bot_id] != events_by_bot.get(bot_id, 0)
+           for bot_id in ready_bot_ids):
+        return {"status": "incomplete", "events": None}
+
+    ordered_events = [
+        {"bot_id": bot_id, "round": round_number, "turn": turn_number}
+        for bot_id, round_number, turn_number in sorted(
+            events, key=lambda event: (event[1], event[2], event[0]))
+    ]
+    return {"status": "captured", "events": ordered_events}
+
+
+def java_env_for_skipped_turn_telemetry(enabled):
+    """Controls the telemetry property in the runner JVM and any bot JVMs it starts."""
+    env = os.environ.copy()
+    options = env.get("JAVA_TOOL_OPTIONS", "")
+    property_option = re.compile(
+        rf"(?<!\S)-D{re.escape(SKIPPED_TURN_TELEMETRY_PROPERTY)}(?:=[^\s]*)?(?=\s|$)")
+    options = property_option.sub(" ", options).strip()
+    if enabled:
+        options = " ".join(
+            value for value in (options, f"-D{SKIPPED_TURN_TELEMETRY_PROPERTY}=true") if value)
+    if options:
+        env["JAVA_TOOL_OPTIONS"] = options
+    else:
+        env.pop("JAVA_TOOL_OPTIONS", None)
+    return env
+
+
 def stage_bot_dirs(bot_dir: Path, participants):
     """Returns the list of bot directories for a battle: the original plus enough copies
     to reach the division's participant count."""
@@ -949,7 +1033,8 @@ def wrap_jar_for_tr(jar_path: Path, classname, version, opts, staging_name="tr-b
     shutil.copyfile(jar_path, staging / jar_path.name)
 
     returncode, output, timed_out = run_java(
-        ["java", "-jar", opts.wrapper_jar, str(staging)], cwd=staging, timeout=120)
+        ["java", "-jar", opts.wrapper_jar, str(staging)], cwd=staging, timeout=120,
+        env=java_env_for_skipped_turn_telemetry(False))
     if returncode != 0:
         return None, f"robots-wrapper failed (exit {returncode}):\n{output}"
 
@@ -997,6 +1082,9 @@ def run_tr_battle(jar_path: Path, classname, version, opts, setup, rc_signatures
     robot. When the Tank Royale side emits one that is not in it, C-004 says to stop: the
     same bot misbehaving only under the bridge is a categorical fact, and finishing the
     battle to produce a score for it spends minutes to learn nothing further."""
+    capture_skipped_turns = getattr(opts, "capture_skipped_turns", False)
+    unavailable_telemetry = {"status": "incomplete", "events": None} \
+        if capture_skipped_turns else {"status": "disabled", "events": None}
     bot_dir, wrap_error = wrap_jar_for_tr(
         jar_path, classname, version, opts, team=setup.get("team", False))
     if wrap_error:
@@ -1004,6 +1092,7 @@ def run_tr_battle(jar_path: Path, classname, version, opts, setup, rc_signatures
             "ok": False, "score": None, "scores": [], "elapsed": 0.0,
             "errors": ["HARNESS: " + wrap_error.splitlines()[0]],
             "error_count": 1, "log_text": "=== Wrapping failed ===\n" + wrap_error,
+            "skipped_turn_telemetry": unavailable_telemetry,
         }
 
     if setup.get("team", False):
@@ -1033,6 +1122,7 @@ def run_tr_battle(jar_path: Path, classname, version, opts, setup, rc_signatures
                 "ok": False, "score": None, "scores": [], "elapsed": 0.0,
                 "errors": ["HARNESS: " + enemy_error.splitlines()[0]],
                 "error_count": 1, "log_text": "=== Wrapping opponent failed ===\n" + enemy_error,
+                "skipped_turn_telemetry": unavailable_telemetry,
             }
         bot_dirs.append(enemy_dir)
     out_file = WORK_DIR / "tr-result.json"
@@ -1053,8 +1143,9 @@ def run_tr_battle(jar_path: Path, classname, version, opts, setup, rc_signatures
     watcher = None
     if rc_signatures is not None:
         watcher = BridgeOnlyErrorWatcher(staged_log_dirs(bot_dirs), rc_signatures)
+    java_env = java_env_for_skipped_turn_telemetry(capture_skipped_turns)
     returncode, output, timed_out = run_java(
-        cmd, cwd=WORK_DIR, timeout=opts.timeout, abort_when=watcher)
+        cmd, cwd=WORK_DIR, timeout=opts.timeout, abort_when=watcher, env=java_env)
     elapsed = time.monotonic() - started
 
     result = summarize_worker_result(
@@ -1085,6 +1176,9 @@ def run_tr_battle(jar_path: Path, classname, version, opts, setup, rc_signatures
         result["bridge_only_signatures"] = sorted(watcher.found)
         result["score"] = None
         result["scores"] = []
+    result["skipped_turn_telemetry"] = skipped_turn_telemetry(
+        bot_dirs, capture_skipped_turns, result.get("completed", False),
+        len(staged_log_dirs(bot_dirs)))
     return result
 
 
@@ -1365,6 +1459,8 @@ def parse_args():
                    help="java executable for the classic side; must be JDK 23 or older, "
                         "since newer releases removed the SecurityManager classic needs "
                         "(auto-detected when not given)")
+    p.add_argument("--capture-skipped-turns", action="store_true",
+                   help="record Tank Royale bridge skipped-turn events, including warm-up turns")
 
     gate = p.add_argument_group("regression gate (C-004)")
     gate.add_argument("--regression", action="store_true",
@@ -1432,6 +1528,7 @@ def measure_repeatedly(jar, classname, version, opts, setup, repeats,
     factor of forty between runs on the classic engine alone (AN-001)."""
     rc_scores, tr_scores, deltas = [], [], []
     bridge_only = []
+    telemetry_runs = []
     attempts = 0
     for attempt in range(repeats):
         attempts += 1
@@ -1444,6 +1541,11 @@ def measure_repeatedly(jar, classname, version, opts, setup, repeats,
                            enemy_jar_paths=enemy_jar_paths,
                            enemy_classes=enemy_classes)
         attach_error_signatures(tr)
+        if getattr(opts, "capture_skipped_turns", False):
+            telemetry_runs.append({
+                "attempt": attempts,
+                **tr.get("skipped_turn_telemetry", {"status": "incomplete", "events": None}),
+            })
         if tr.get("aborted_on_bridge_only_error"):
             bridge_only = tr.get("bridge_only_signatures", [])
             break
@@ -1457,12 +1559,15 @@ def measure_repeatedly(jar, classname, version, opts, setup, repeats,
         print(f"      repeat {attempt + 1}/{repeats}: RC={fmt_score(rc.get('score'))} "
               f"TR={fmt_score(tr.get('score'))} "
               f"delta={'-' if delta is None else f'{delta:+.1f}%'}", flush=True)
-    return {
+    measured = {
         "rc_mean": mean(rc_scores), "tr_mean": mean(tr_scores),
         "delta_mean": mean(deltas), "samples": len(deltas), "attempts": attempts,
         "deltas": deltas,
         "bridge_only_signatures": bridge_only,
     }
+    if getattr(opts, "capture_skipped_turns", False):
+        measured["skipped_turn_telemetry_runs"] = telemetry_runs
+    return measured
 
 
 def run_regression(opts):
@@ -1492,6 +1597,9 @@ def run_regression(opts):
         measured = measure_repeatedly(
             jar, classname, version, opts, setup, repeats,
             enemy_jar_paths=enemy_jar_paths, enemy_classes=enemy_classes)
+        if "skipped_turn_telemetry_runs" in measured:
+            print("    skipped-turn telemetry runs: " + json.dumps(
+                measured["skipped_turn_telemetry_runs"], separators=(",", ":")), flush=True)
 
         if measured["bridge_only_signatures"]:
             verdict = "BRIDGE-ONLY ERROR"
@@ -1896,6 +2004,11 @@ def run_conformance(opts):
         if opts.enemy_class:
             staging_dirs.append(WORK_DIR / "tr-bots-enemy")
         result["consoles"] = collect_bot_consoles(staging_dirs)
+    if "skipped_turn_telemetry" not in result:
+        result["skipped_turn_telemetry"] = {
+            "status": "unavailable" if opts.capture_skipped_turns else "disabled",
+            "events": None,
+        }
     result.pop("log_text", None)
     result["setup"] = setup
     print(json.dumps(result))
@@ -2079,6 +2192,10 @@ def main():
                     "errors": ["HARNESS: Tank Royale side skipped after classic process cleanup failed"],
                     "error_signatures": [], "bridge_only_signatures": None,
                     "has_log": False, "skipped": None, "stop_sweep": True,
+                    "skipped_turn_telemetry": {
+                        "status": "incomplete" if opts.capture_skipped_turns else "disabled",
+                        "events": None,
+                    },
                 }
             else:
                 tr = run_tr_battle(
@@ -2100,7 +2217,8 @@ def main():
                         "errors", "error_signatures", "has_log", "selected")},
                 "tr": {k: tr.get(k) for k in
                        ("ok", "score", "scores", "error_count", "elapsed",
-                        "errors", "error_signatures", "bridge_only_signatures", "has_log", "skipped")},
+                        "errors", "error_signatures", "bridge_only_signatures", "has_log",
+                        "skipped", "skipped_turn_telemetry")},
                 "completed_at": now_iso(),
             }
             if retest:
diff --git a/compat-test/test_parity_registry.py b/compat-test/test_parity_registry.py
index 2fff23d9..4418f4ce 100644
--- a/compat-test/test_parity_registry.py
+++ b/compat-test/test_parity_registry.py
@@ -136,7 +136,7 @@ def testHARN001_UnitPositive_TeamMemberDirsReadWindows1252Metadata(self):
 
             self.assertEqual([member_dir], harness.team_member_dirs(team_dir))
 
-    def testHARN008_UnitPositive_RobocodeVersionReadsInstallReleaseHeading(self):
+    def testUnitPositive_RobocodeVersionReadsInstallReleaseHeading(self):
         with tempfile.TemporaryDirectory() as directory:
             root = Path(directory)
             (root / "versions.md").write_text(
@@ -144,7 +144,7 @@ def testHARN008_UnitPositive_RobocodeVersionReadsInstallReleaseHeading(self):
             self.assertEqual("1.11.1", harness.resolve_robocode_version(root))
             self.assertIsNone(harness.robocode_version_error(root, "1.11.1"))
 
-    def testHARN008_UnitPositive_RobocodeVersionFallsBackToUniqueEngineVersion(self):
+    def testUnitPositive_RobocodeVersionFallsBackToUniqueEngineVersion(self):
         with tempfile.TemporaryDirectory() as directory:
             root = Path(directory)
             (root / "libs").mkdir()
@@ -152,14 +152,14 @@ def testHARN008_UnitPositive_RobocodeVersionFallsBackToUniqueEngineVersion(self)
             (root / "libs" / "robocode.host-1.11.1.jar").write_bytes(b"")
             self.assertEqual("1.11.1", harness.resolve_robocode_version(root))
 
-    def testHARN008_UnitNegative_UnsupportedRobocodeVersionIsRejected(self):
+    def testUnitNegative_UnsupportedRobocodeVersionIsRejected(self):
         with tempfile.TemporaryDirectory() as directory:
             root = Path(directory)
             (root / "versions.md").write_text("## Version 1.9.4.2\n", encoding="utf-8")
             error = harness.robocode_version_error(root)
         self.assertIn("not in LiteRumble's allowed client list", error)
 
-    def testHARN008_UnitNegative_UnknownRobocodeVersionIsRejected(self):
+    def testUnitNegative_UnknownRobocodeVersionIsRejected(self):
         with tempfile.TemporaryDirectory() as directory:
             error = harness.robocode_version_error(Path(directory))
         self.assertIn("could not be determined", error)
@@ -358,6 +358,139 @@ def testHARN007_UnitNegative_FixedMeleeSelectionRejectsTooSmallPool(self):
         with self.assertRaises(ValueError):
             harness.select_melee_opponent_names("robot-0.jar", pool)
 
+    def testHARN008_UnitNegative_DisabledCaptureDoesNotClaimZeroEvents(self):
+        self.assertEqual(
+            {"status": "disabled", "events": None},
+            harness.skipped_turn_telemetry([], False, True, 0),
+        )
+
+    def testHARN008_UnitNegative_IncompleteCaptureDoesNotClaimZeroEvents(self):
+        self.assertEqual(
+            {"status": "incomplete", "events": None},
+            harness.skipped_turn_telemetry([], True, False, 0),
+        )
+
+    def testHARN008_UnitNegative_MissingBridgeReadinessIsUnavailable(self):
+        with tempfile.TemporaryDirectory() as directory:
+            bot_dir = Path(directory) / "bot"
+            bot_dir.mkdir()
+            (bot_dir / "stdout.log").write_text("", encoding="utf-8")
+
+            result = harness.skipped_turn_telemetry([bot_dir], True, True, 1)
+
+        self.assertEqual({"status": "unavailable", "events": None}, result)
+
+    def testHARN008_UnitPositive_CaptureDeduplicatesAndKeepsWarmupTurns(self):
+        with tempfile.TemporaryDirectory() as directory:
+            first = Path(directory) / "bot-1"
+            second = Path(directory) / "bot-2"
+            first.mkdir()
+            second.mkdir()
+            (first / "stdout.log").write_text(
+                "BRIDGE_SKIPPED_TURN_TELEMETRY_READY botId=11\n"
+                "BRIDGE_SKIPPED_TURN botId=11 round=1 turn=4\n"
+                "BRIDGE_SKIPPED_TURN botId=11 round=1 turn=4\n"
+                "BRIDGE_SKIPPED_TURN botId=11 round=1 turn=2\n"
+                "BRIDGE_SKIPPED_TURN_TELEMETRY_COMPLETE botId=11 eventCount=2\n",
+                encoding="utf-8")
+            (second / "stdout.log").write_text(
+                "BRIDGE_SKIPPED_TURN_TELEMETRY_READY botId=12\n"
+                "BRIDGE_SKIPPED_TURN botId=12 round=2 turn=1\n"
+                "BRIDGE_SKIPPED_TURN_TELEMETRY_COMPLETE botId=12 eventCount=1\n",
+                encoding="utf-8")
+
+            result = harness.skipped_turn_telemetry(
+                [first, second], True, True, expected_bots=2)
+
+        self.assertEqual("captured", result["status"])
+        self.assertEqual([
+            {"bot_id": 11, "round": 1, "turn": 2},
+            {"bot_id": 11, "round": 1, "turn": 4},
+            {"bot_id": 12, "round": 2, "turn": 1},
+        ], result["events"])
+
+    def testHARN008_UnitPositive_CompletedCaptureCanReportZeroEvents(self):
+        with tempfile.TemporaryDirectory() as directory:
+            bot_dir = Path(directory) / "bot"
+            bot_dir.mkdir()
+            (bot_dir / "stdout.log").write_text(
+                "BRIDGE_SKIPPED_TURN_TELEMETRY_READY botId=11\n"
+                "BRIDGE_SKIPPED_TURN_TELEMETRY_COMPLETE botId=11 eventCount=0\n",
+                encoding="utf-8")
+
+            result = harness.skipped_turn_telemetry([bot_dir], True, True, 1)
+
+        self.assertEqual({"status": "captured", "events": []}, result)
+
+    def testHARN008_UnitNegative_MissingLogMakesCaptureIncomplete(self):
+        with tempfile.TemporaryDirectory() as directory:
+            bot_dir = Path(directory) / "bot"
+            bot_dir.mkdir()
+
+            result = harness.skipped_turn_telemetry([bot_dir], True, True, 1)
+
+        self.assertEqual({"status": "incomplete", "events": None}, result)
+
+    def testHARN008_UnitNegative_MissingCompletionMarkerDoesNotClaimZeroEvents(self):
+        with tempfile.TemporaryDirectory() as directory:
+            bot_dir = Path(directory) / "bot"
+            bot_dir.mkdir()
+            (bot_dir / "stdout.log").write_text(
+                "BRIDGE_SKIPPED_TURN_TELEMETRY_READY botId=11\n"
+                "BRIDGE_SKIPPED_TURN botId=11 round=1 turn=3\n",
+                encoding="utf-8")
+
+            result = harness.skipped_turn_telemetry([bot_dir], True, True, 1)
+
+        self.assertEqual({"status": "incomplete", "events": None}, result)
+
+    def testHARN008_UnitNegative_CompletionCountDetectsTruncatedEvents(self):
+        with tempfile.TemporaryDirectory() as directory:
+            bot_dir = Path(directory) / "bot"
+            bot_dir.mkdir()
+            (bot_dir / "stdout.log").write_text(
+                "BRIDGE_SKIPPED_TURN_TELEMETRY_READY botId=11\n"
+                "BRIDGE_SKIPPED_TURN botId=11 round=1 turn=3\n"
+                "BRIDGE_SKIPPED_TURN_TELEMETRY_COMPLETE botId=11 eventCount=2\n",
+                encoding="utf-8")
+
+            result = harness.skipped_turn_telemetry([bot_dir], True, True, 1)
+
+        self.assertEqual({"status": "incomplete", "events": None}, result)
+
+    def testHARN008_UnitPositive_OptInOverridesOnlyTelemetryJvmProperty(self):
+        with patch.dict(harness.os.environ, {
+                "JAVA_TOOL_OPTIONS": "-Xmx512m -Drobocode.bridge.skippedTurnTelemetry=false"
+        }, clear=True):
+            env = harness.java_env_for_skipped_turn_telemetry(True)
+
+        self.assertEqual(
+            "-Xmx512m -Drobocode.bridge.skippedTurnTelemetry=true",
+            env["JAVA_TOOL_OPTIONS"])
+
+    def testHARN008_UnitNegative_DisabledRemovesInheritedTelemetryProperty(self):
+        with patch.dict(harness.os.environ, {
+                "JAVA_TOOL_OPTIONS": "-Xmx512m -Drobocode.bridge.skippedTurnTelemetry=true"
+        }, clear=True):
+            env = harness.java_env_for_skipped_turn_telemetry(False)
+
+        self.assertEqual("-Xmx512m", env["JAVA_TOOL_OPTIONS"])
+
+    def testHARN008_UnitPositive_TelemetryPersistsInAppendOnlyObservation(self):
+        telemetry = {
+            "status": "captured",
+            "events": [{"bot_id": 11, "round": 1, "turn": 2}],
+        }
+        state = {"robots": {"roborumble/a.Bot_1.0.jar": {
+            "status": "PASS", "delta_pct": 0.0, "completed_at": "2026-09-11T00:00:00Z",
+            "setup": {}, "rc": {}, "tr": {"skipped_turn_telemetry": telemetry},
+        }}}
+        data = {"schema_version": 1, "subjects": {}}
+
+        self.assertEqual(1, registry.sync_state(data, state, Path("missing"), {}))
+        observation = data["subjects"]["roborumble/a.Bot_1.0.jar"]["observations"][0]
+        self.assertEqual(telemetry, observation["tank_royale"]["skipped_turn_telemetry"])
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/docs/analysis/AN-016-skipped-turn-telemetry-source.md b/docs/analysis/AN-016-skipped-turn-telemetry-source.md
new file mode 100644
index 00000000..97c64f7e
--- /dev/null
+++ b/docs/analysis/AN-016-skipped-turn-telemetry-source.md
@@ -0,0 +1,46 @@
+---
+id: AN-016
+type: analysis
+status: active
+links: [P-001, CAP-007]
+title: A bounded source for per-turn skipped-turn telemetry
+provenance: inferred
+reversal-cost: low
+carried-by: [CAP-007, DES-007, CRIT-007]
+---
+
+# AN-016 — A bounded source for per-turn skipped-turn telemetry
+
+## Risk investigated
+
+Whether compatibility measurements can record the exact bot, round, and turn for skipped-turn events without mistaking unavailable telemetry for zero skips.
+
+## Evidence boundary
+
+This spike ran on Windows with PowerShell, JDK 25, classic Robocode 1.11.1, bridge worktree `ch-018-record-skipped-turn-telemetry` at `7e06e2a`, and Tank Royale worktree revision `21324d6b7c4433e3fc1ba2a0e29c691fc3565e47`. The Tank Royale worktree had unrelated GUI edits before the spike; no source files there were changed. The runner 1.4.0 fat JAR and Bot API 1.4.0 JAR were built from that local Tank Royale revision. This is prepared-environment evidence, not a clean-checkout or release-pair claim.
+
+## What was tried
+
+The classic Control API snapshot interface was inspected with `javap`. `IRobotSnapshot` exposes only `ACTIVE`, `HIT_WALL`, `HIT_ROBOT`, and `DEAD`; it does not expose skipped-turn events or a skipped-turn counter. Classic robots can report callbacks themselves, as the bridge-owned `SkippedTurnProbe` does, but that cannot establish zero skips for arbitrary silent robots.
+
+Tank Royale's local runner source exposes opt-in `enableTurnTimingDiagnostics(30)`. The runner passes a diagnostics system property to the embedded server and redirects server output through JUL. The server records `skipped-turn-detected` with bot ID, round, and turn, then emits nearby timing records when the server stops.
+
+A source-mode Java spike enabled that runner diagnostic and ran a temporary bot that slept 200 ms before each intent with a 1 ms turn timeout. The battle completed one round, and the JUL handler captured server diagnostics including exact bot/round/turn tuples. The emitted skip lines repeated tuples from overlapping diagnostic windows, and the server stores timing records in a bounded 24,000-record ring. This proves the local capture route works for a bounded forced-skip run; it does not establish that it retains every skip in a long battle.
+
+The spike made no TPS or performance claim. An earlier filtered Gradle integration-test attempt pulled in unrelated .NET test dependencies and was stopped before the requested runner test began; that attempt is not counted as a test result.
+
+## Findings
+
+Bridge-side telemetry at `BotPeer`'s skipped-turn dispatch records the event at the boundary the compatibility layer receives, before the legacy robot's callback runs. It can be enabled only for measurement runs and preserves the exact bot ID, round, and skipped turn number. It buffers records in memory and flushes them at `GameEnded`, avoiding a file write on each skipped-turn callback. A final marker per bot reports the number of unique tuples so the harness can detect an interrupted flush. It avoids the runner's repeated timing windows and bounded timing buffer.
+
+After implementation, three one-round local Tank Royale runs of the existing `SkippedTurnProbe` with two bridge bots reported 84, 82, and 76 unique event tuples. In each run, per-bot comparison matched every tuple's turn number to exactly one `SkippedTurnReported` callback line, and each completion marker's count matched its bot's tuples. A run without `--capture-skipped-turns` reported `disabled` with `events: null` and emitted no bridge markers, even when the parent environment supplied the telemetry property. These runs used the locally built bridge/wrapper with the Bot API and runner from the same Tank Royale 1.4.0 worktree revision; this is local conformance evidence, not a release or cross-machine performance claim.
+
+A three-member team probe completed with two runner score groups and six bot-process logs. Counting scores as bots first produced `unavailable`; the harness now validates readiness against the expanded staged member directories and reported a completed capture with zero events. This confirms that team captures count bridge processes rather than runner score groups.
+
+The first end-to-end attempt also showed that `bot.getMyId()` is unavailable during `BotPeer` construction. The readiness marker now comes from `GameStartedEvent`, after the Bot API has assigned the ID; the forced-skip run passed after that correction.
+
+This source measures skipped-turn events delivered to the bridge. It does not claim to observe a server-detected event that never reaches the bridge. Disabled capture, an incomplete battle, and a completed capture with no events must remain distinguishable. Historical registry observations stay unmeasured.
+
+## Rejected interpretation
+
+An empty bot log or missing server log line is not evidence of zero skips. The optional runner trace is useful for broader timing diagnosis, but its repeated windows and bounded ring are not the compatibility registry's per-event source.
diff --git a/docs/analysis/README.md b/docs/analysis/README.md
index cd033170..4ae1eb69 100644
--- a/docs/analysis/README.md
+++ b/docs/analysis/README.md
@@ -22,4 +22,5 @@ An incident where the corpus was green but later evidence contradicted it carrie
 - [AN-012 — M-003 finds one bridge-only lifecycle failure and no reproducible higher-score gap in the other two candidates](AN-012-m-003-higher-score-gaps-do-not-reproduce.md) · `active` — The three higher-score candidates were re-measured at official `roborumble` parameters: ScalarR has a named bridge-only lifecycle failure, while Ar1 and BasicSurfer are within the band.
 - [AN-013 — Tank Royale's native team model corresponds closely enough to classic's to map onto directly](AN-013-tank-royale-team-model-corresponds-to-classic.md) · `active` — `docs/capabilities/CAP-006-team-robot-support/design.md` left one decision open before any `M-005` implementation: does Tank Royale's team concept correspond closely enough to classic Robocode's to…
 - [AN-015 — The first melee registry cases are contaminated by fixed-opponent failures](AN-015-melee-registry-errors-are-opponent-contaminated.md) · `active` — Why the first official melee observations cannot yet be read as independent subject failures, and which bridge gaps remain separate investigations.
+- [AN-016 — A bounded source for per-turn skipped-turn telemetry](AN-016-skipped-turn-telemetry-source.md) · `active` — Whether compatibility measurements can record the exact bot, round, and turn for skipped-turn events without mistaking unavailable telemetry for zero skips.
 <!-- clue:index:end -->
diff --git a/docs/capabilities/CAP-007-compatibility-harness/criteria.md b/docs/capabilities/CAP-007-compatibility-harness/criteria.md
index 7eb8c668..28762387 100644
--- a/docs/capabilities/CAP-007-compatibility-harness/criteria.md
+++ b/docs/capabilities/CAP-007-compatibility-harness/criteria.md
@@ -76,4 +76,15 @@ Feature: The compatibility harness
     When its battle setup is resolved
     Then the battlefield, round count, and participant count are that division's official values
     # The harness currently uses one setup for every division. Plan door: M-001.
+
+  @HARN-008 @draft
+  Scenario: Skipped-turn telemetry preserves events and distinguishes missing capture from zero
+    Test-type: Integration
+    Given a completed Tank Royale compatibility run with telemetry enabled
+    When the bridge receives skipped-turn events
+    Then the observation records one event per distinct bot ID, round, and skipped turn number, including warm-up turns
+    And a completed enabled run with no events is captured with an empty event list
+    And disabled, unavailable, or incomplete capture has a distinct status and does not claim zero events
+    # Callback-level telemetry is opt-in and does not claim to see server events that never reach the bridge. Plan door: M-006.
+    # The harness is Python and is not yet a supported evidence carrier.
 ```
diff --git a/docs/capabilities/CAP-007-compatibility-harness/design.md b/docs/capabilities/CAP-007-compatibility-harness/design.md
index 55322a41..5326ddbc 100644
--- a/docs/capabilities/CAP-007-compatibility-harness/design.md
+++ b/docs/capabilities/CAP-007-compatibility-harness/design.md
@@ -10,7 +10,7 @@ reversal-cost: low
 
 # CAP-007 — design
 
-`status: draft`: the orchestration and isolation described here exist; the division setups, averaging, fail-fast, and tracing do not.
+`status: draft`: the orchestration, isolation, and opt-in skipped-turn capture described here exist; the division setups, averaging, fail-fast, and tracing do not.
 
 ## Shape
 
@@ -34,6 +34,8 @@ Compare: scores as the sum of all staged participants' totals, errors as normali
 
 The harness imports an interrupted checkpoint with `--sync-registry`, runs new first-pass work in bounded `--limit` batches, and selects retests with `--retry-unresolved` or `--retest-cause`. Matched subjects stay recorded and are not selected after an unrelated repair.
 
+Skipped-turn capture is opt-in with `--capture-skipped-turns`. For a completed Tank Royale run, `tank_royale.skipped_turn_telemetry` in each registry observation has `status: captured` and an `events` list containing distinct `{bot_id, round, turn}` records in round/turn order; warm-up turns are included. `disabled`, `unavailable`, and `incomplete` statuses carry `events: null`, so only a completed capture can report an empty list. The bridge buffers each bot's readiness and event markers until `GameEnded`, then writes a completion marker with its distinct-event count; the harness checks both markers against the registry events before reporting capture as complete. These records cover `SkippedTurnEvent` callbacks delivered to bridge bots and do not claim to observe server detections that never reach a bot.
+
 ## What changes for the milestone
 
 **Division setups.** One named constant per division carrying the official battlefield, rounds, and participant count, and one constant for the collection root — `C-003` and `C-007`. The single hard-coded setup goes away.
diff --git a/docs/plans/P-001-bridge-parity-campaign.md b/docs/plans/P-001-bridge-parity-campaign.md
index 2c9024fb..839e9188 100644
--- a/docs/plans/P-001-bridge-parity-campaign.md
+++ b/docs/plans/P-001-bridge-parity-campaign.md
@@ -83,6 +83,7 @@ They are bookkeeping rather than a second plan. A door closes when its criterion
 | M-141 | `EVT-013` | `EVT-013` is active, with evidence attributable to it. Successor to `EVT-003` (`M-103`). Work lands under M-001. | done |
 | M-142 | `EVT-014` | `EVT-014` is active, with evidence attributable to it. Successor to `EVT-007` (`M-107`). Work lands under M-001. | done |
 | M-143 | `EVT-015` | `EVT-015` is active, with evidence attributable to it. Successor to `EVT-001` (`M-101`). Work lands under M-001. | done |
+| M-148 | `HARN-008` | `HARN-008` is active, with evidence attributable to it. Work lands under M-006. | todo |
 
 ## Why this order
 
diff --git a/robocode-api/src/main/java/dev/robocode/tankroyale/bridge/BotPeer.java b/robocode-api/src/main/java/dev/robocode/tankroyale/bridge/BotPeer.java
index 093933ee..0dd0cca6 100644
--- a/robocode-api/src/main/java/dev/robocode/tankroyale/bridge/BotPeer.java
+++ b/robocode-api/src/main/java/dev/robocode/tankroyale/bridge/BotPeer.java
@@ -35,6 +35,11 @@
 
 public final class BotPeer implements ITeamRobotPeer, IJuniorRobotPeer {
 
+    private static final String SKIPPED_TURN_TELEMETRY_PROPERTY =
+            "robocode.bridge.skippedTurnTelemetry";
+    private static final boolean SKIPPED_TURN_TELEMETRY_ENABLED =
+            Boolean.getBoolean(SKIPPED_TURN_TELEMETRY_PROPERTY);
+
     private volatile IBasicRobot robot;
     private volatile IBasicEvents basicEvents;
     private volatile IAdvancedEvents advancedEvents;
@@ -54,6 +59,10 @@ public final class BotPeer implements ITeamRobotPeer, IJuniorRobotPeer {
     private boolean hitWallHandlerActive;
     private boolean hitWallHandlerBlocked;
     private boolean suppressScansForBlockedWallHandler;
+    private final List<String> skippedTurnTelemetryRecords = SKIPPED_TURN_TELEMETRY_ENABLED
+            ? new ArrayList<>() : Collections.emptyList();
+    private final Set<String> skippedTurnTelemetryEventRecords = SKIPPED_TURN_TELEMETRY_ENABLED
+            ? new HashSet<>() : Collections.emptySet();
 
     @SuppressWarnings("unused")
     public BotPeer(IBasicRobot robot, BotInfo botInfo) {
@@ -445,10 +454,30 @@ private void dispatchRobotDeathEvent(BotDeathEvent botDeathEvent) {
     private void dispatchSkippedTurnEvent(BotEvent botEvent) {
         log("-> onSkippedTurn");
         var skippedTurnEvent = (SkippedTurnEvent) botEvent;
+        if (SKIPPED_TURN_TELEMETRY_ENABLED) {
+            String record = "BRIDGE_SKIPPED_TURN botId=" + bot.getMyId()
+                    + " round=" + bot.getRoundNumber()
+                    + " turn=" + skippedTurnEvent.getTurnNumber();
+            if (skippedTurnTelemetryEventRecords.add(record)) {
+                skippedTurnTelemetryRecords.add(record);
+            }
+        }
         var robocodeEvent = new robocode.SkippedTurnEvent(skippedTurnEvent.getTurnNumber());
         dispatchRobotCallback(() -> advancedEvents.onSkippedTurn(robocodeEvent));
     }
 
+    private void flushSkippedTurnTelemetry() {
+        if (SKIPPED_TURN_TELEMETRY_ENABLED) {
+            for (String record : skippedTurnTelemetryRecords) {
+                System.out.println(record);
+            }
+            System.out.println("BRIDGE_SKIPPED_TURN_TELEMETRY_COMPLETE botId=" + bot.getMyId()
+                    + " eventCount=" + skippedTurnTelemetryEventRecords.size());
+            skippedTurnTelemetryRecords.clear();
+            skippedTurnTelemetryEventRecords.clear();
+        }
+    }
+
     private void dispatchDeathEvent() {
         log("-> onDeath");
         var robocodeEvent = new robocode.DeathEvent();
@@ -1252,6 +1281,10 @@ public void onTeamMessage(TeamMessageEvent teamMessageEvent) {
         @Override
         public void onGameStarted(GameStartedEvent gameStatedEvent) {
             totalTurns.set(0);
+            if (SKIPPED_TURN_TELEMETRY_ENABLED) {
+                skippedTurnTelemetryRecords.add(
+                        "BRIDGE_SKIPPED_TURN_TELEMETRY_READY botId=" + bot.getMyId());
+            }
             // Legacy robots may read battlefield dimensions from setPeer(). The Bot API fills
             // GameSetup immediately before publishing this callback, so attach the peer here
             // instead of before the connection has received game setup.
@@ -1260,6 +1293,7 @@ public void onGameStarted(GameStartedEvent gameStatedEvent) {
 
         @Override
         public void onGameEnded(GameEndedEvent gameEndedEvent) {
+            flushSkippedTurnTelemetry();
             log("-> onBattleEnded");
             if (basicEvents instanceof IBasicEvents2) {
                 ((IBasicEvents2) basicEvents).onBattleEnded(new robocode.BattleEndedEvent(