From a09e6b14ce4de17116d730b0da2f616ef6ecee69 Mon Sep 17 00:00:00 2001
From: wuyang <5700876+banisherwy@user.noreply.gitee.com>
Date: Thu, 30 Jul 2026 04:23:14 +0800
Subject: [PATCH] research: freeze Chat prompts and CRN runner

---
 .../v2_lite_chat_task_bootstrap_crn_probe.py  | 1366 +++++++++++++++++
 ..._V2_LITE_CHAT_TASK_BOOTSTRAP_MANIFEST.json | 1035 +++++++++++--
 ...EK_V2_LITE_CHAT_TASK_BOOTSTRAP_PROTOCOL.md |   25 +-
 ...-deepseek-chat-task-bootstrap-manifest.mjs |    7 +-
 ...ze-deepseek-chat-task-bootstrap-prompts.py |  172 +++
 5 files changed, 2469 insertions(+), 136 deletions(-)
 create mode 100644 experiments/deepseek/v2_lite_chat_task_bootstrap_crn_probe.py
 create mode 100644 scripts/freeze-deepseek-chat-task-bootstrap-prompts.py

diff --git a/experiments/deepseek/v2_lite_chat_task_bootstrap_crn_probe.py b/experiments/deepseek/v2_lite_chat_task_bootstrap_crn_probe.py
new file mode 100644
index 0000000..13025fb
--- /dev/null
+++ b/experiments/deepseek/v2_lite_chat_task_bootstrap_crn_probe.py
@@ -0,0 +1,1366 @@
+#!/usr/bin/env python3
+"""Run the preregistered task-bootstrap grid with explicit common random numbers.
+
+The model and the official temperature/top-p distribution are pinned, but the
+discrete draw is intentionally not ``torch.multinomial``.  For each
+source+tape+step, a SHA-256-derived uniform variate is shared across the four
+prompt conditions and mapped through each row's token-ID-ordered CDF.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import platform
+import resource
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+from statistics import mean
+from typing import Any
+
+import accelerate
+import safetensors
+import torch
+import transformers
+from transformers import (
+    AutoTokenizer,
+    TemperatureLogitsWarper,
+    TopPLogitsWarper,
+)
+
+import v2_lite_chat_sampling_probe as sampling
+import v2_lite_chat_special_token_behavior_probe as behavior
+import v2_lite_routing_special_token_family_control as special
+
+
+PROTOCOL_ID = "llm-atlas-deepseek-chat-task-bootstrap-crn-v1"
+MANIFEST_SHA256 = (
+    "6313e70536c464fe598a930355767524"
+    "18f08016dfd60ac246437c3b43bf2ae1"
+)
+CONDITIONS = (
+    "s0_eos",
+    "s1_eos",
+    "s0_period",
+    "s1_period",
+)
+DOMAINS = ("code", "math")
+TEMPERATURE = 0.3
+TOP_P = 0.95
+TOP_K = 0
+FORMAL_MAX_NEW_TOKENS = 512
+SMOKE_MAX_NEW_TOKENS = 16
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--execution-mode",
+        choices=("smoke", "formal", "replay"),
+        required=True,
+    )
+    parser.add_argument("--artifact-dir", type=Path, required=True)
+    parser.add_argument("--manifest", type=Path, required=True)
+    parser.add_argument(
+        "--reference-routing-json",
+        type=Path,
+        required=True,
+    )
+    parser.add_argument("--human-eval", type=Path, required=True)
+    parser.add_argument("--gsm8k", type=Path, required=True)
+    parser.add_argument("--tnews", type=Path, required=True)
+    parser.add_argument("--tnews-archive", type=Path, required=True)
+    parser.add_argument("--wikitext", type=Path, required=True)
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--journal-dir", type=Path)
+    parser.add_argument("--resume", action="store_true")
+    parser.add_argument("--gpu-memory", default="28GiB")
+    parser.add_argument("--cpu-memory", default="80GiB")
+    parser.add_argument("--captured-at", default=None)
+    return parser.parse_args()
+
+
+def sha256_bytes(payload: bytes) -> str:
+    return hashlib.sha256(payload).hexdigest()
+
+
+def sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        while chunk := handle.read(16 * 1024 * 1024):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def canonical_hash(value: Any) -> str:
+    return sha256_bytes(
+        json.dumps(
+            value,
+            ensure_ascii=False,
+            sort_keys=True,
+            separators=(",", ":"),
+        ).encode()
+    )
+
+
+def install_condition_contract() -> None:
+    factors = {
+        condition: special.FACTORS[condition]
+        for condition in CONDITIONS
+    }
+    special.BOUNDARY_LEVELS = ("eos", "period")
+    special.CONDITIONS = CONDITIONS
+    special.FACTORS = factors
+    special.SYSTEM_CELLS = {
+        "eos": ("s0_eos", "s1_eos"),
+        "period": ("s0_period", "s1_period"),
+    }
+    special.SYSTEM_EDGE_CONTRASTS = {
+        "period_minus_eos": ("eos", "period"),
+    }
+    special.COMPARISONS = (
+        ("system_eos", "s0_eos", "s1_eos"),
+        ("system_period", "s0_period", "s1_period"),
+        ("period_at_s0", "s0_eos", "s0_period"),
+        ("period_at_s1", "s1_eos", "s1_period"),
+    )
+    special.ALIGNMENT_COMPARISONS = special.COMPARISONS
+    special.install_control_contract()
+
+
+def load_manifest(args: argparse.Namespace) -> dict[str, Any]:
+    if sha256_file(args.manifest) != MANIFEST_SHA256:
+        raise RuntimeError("frozen manifest SHA-256 differs")
+    manifest = json.loads(args.manifest.read_text(encoding="utf-8"))
+    if manifest["protocol_id"] != PROTOCOL_ID:
+        raise RuntimeError("manifest protocol ID differs")
+    if manifest["model"]["revision"] != behavior.MODEL_REVISION:
+        raise RuntimeError("manifest model revision differs")
+    if tuple(manifest["conditions"]) != CONDITIONS:
+        raise RuntimeError("manifest condition order differs")
+    if tuple(manifest["domains"]) != DOMAINS:
+        raise RuntimeError("manifest domain order differs")
+    return manifest
+
+
+def validate_args(args: argparse.Namespace) -> None:
+    expected_tokens = (
+        SMOKE_MAX_NEW_TOKENS
+        if args.execution_mode == "smoke"
+        else FORMAL_MAX_NEW_TOKENS
+    )
+    if args.resume and args.journal_dir is None:
+        raise ValueError("--resume requires --journal-dir")
+    if args.execution_mode != "smoke" and args.journal_dir is None:
+        raise ValueError("formal/replay execution requires --journal-dir")
+    for path in (
+        args.artifact_dir,
+        args.manifest,
+        args.reference_routing_json,
+        args.human_eval,
+        args.gsm8k,
+        args.tnews,
+        args.tnews_archive,
+        args.wikitext,
+    ):
+        if not path.exists():
+            raise FileNotFoundError(path)
+    missing = [
+        name
+        for name in behavior.MODEL_FILES
+        if not (args.artifact_dir / name).is_file()
+    ]
+    if missing:
+        raise FileNotFoundError(
+            f"artifact directory is incomplete: {missing}"
+        )
+    if expected_tokens <= 0:
+        raise AssertionError("max-new-token contract is invalid")
+
+
+def tape_uint64(tape: str, source_id: str, step: int) -> int:
+    payload = (
+        f"{PROTOCOL_ID}\0uniform\0"
+        f"{tape}\0{source_id}\0{step}"
+    ).encode()
+    return int.from_bytes(hashlib.sha256(payload).digest()[:8], "big")
+
+
+def uniform_float32(
+    value: int,
+    *,
+    device: torch.device,
+) -> torch.Tensor:
+    if not 0 <= value < 1 << 64:
+        raise ValueError("uniform integer is outside uint64")
+    raw = (value + 0.5) / float(1 << 64)
+    result = torch.tensor(raw, dtype=torch.float32, device=device)
+    zero = torch.tensor(0.0, dtype=torch.float32, device=device)
+    one = torch.tensor(1.0, dtype=torch.float32, device=device)
+    lower = torch.nextafter(zero, one)
+    upper = torch.nextafter(one, zero)
+    return torch.clamp(result, min=lower, max=upper)
+
+
+def inverse_cdf_sample(
+    *,
+    input_ids: torch.Tensor,
+    logits: torch.Tensor,
+    uniform: torch.Tensor,
+    temperature_warper: TemperatureLogitsWarper,
+    top_p_warper: TopPLogitsWarper,
+) -> tuple[torch.Tensor, dict[str, Any]]:
+    scores = temperature_warper(input_ids, logits)
+    scores = top_p_warper(input_ids, scores)
+    finite = torch.isfinite(scores)
+    if not bool(finite.any(dim=-1).all()):
+        raise RuntimeError("a sampling row has no finite logits")
+    probabilities = torch.softmax(scores.float(), dim=-1)
+    if not bool(torch.isfinite(probabilities).all()):
+        raise RuntimeError("sampling probabilities contain NaN/Inf")
+    cdf = torch.cumsum(probabilities, dim=-1)
+    cdf[:, -1] = 1.0
+    row_uniforms = uniform.expand(cdf.shape[0]).contiguous()
+    sampled = torch.searchsorted(
+        cdf.contiguous(),
+        row_uniforms.unsqueeze(-1),
+        right=False,
+    ).squeeze(-1)
+    if bool((sampled >= cdf.shape[-1]).any()):
+        raise RuntimeError("inverse-CDF search exceeded vocabulary")
+    return sampled, {
+        "finite_tokens_per_row": finite.sum(dim=-1).detach().cpu().tolist(),
+        "probability_sum_per_row": probabilities.sum(
+            dim=-1
+        ).detach().cpu().tolist(),
+    }
+
+
+def synthetic_sampler_test() -> dict[str, Any]:
+    input_ids = torch.tensor([[1], [1]], dtype=torch.long)
+    logits = torch.tensor(
+        [[-3.0, 4.0, 1.0, 0.0], [0.0, 1.0, 4.0, -3.0]],
+        dtype=torch.float32,
+    )
+    temperature_warper = TemperatureLogitsWarper(TEMPERATURE)
+    top_p_warper = TopPLogitsWarper(
+        TOP_P,
+        min_tokens_to_keep=1,
+    )
+    observations = []
+    for name, value in (
+        ("low", 0),
+        ("middle", 1 << 63),
+        ("high", (1 << 64) - 1),
+    ):
+        uniform = uniform_float32(value, device=logits.device)
+        sampled, audit = inverse_cdf_sample(
+            input_ids=input_ids,
+            logits=logits,
+            uniform=uniform,
+            temperature_warper=temperature_warper,
+            top_p_warper=top_p_warper,
+        )
+        observations.append(
+            {
+                "name": name,
+                "uint64": value,
+                "uniform_float32": float(uniform.item()),
+                "sampled": sampled.tolist(),
+                "audit": audit,
+            }
+        )
+    passed = (
+        0 < observations[0]["uniform_float32"] < 1
+        and 0 < observations[-1]["uniform_float32"] < 1
+        and all(
+            all(count < logits.shape[-1] for count in row["audit"][
+                "finite_tokens_per_row"
+            ])
+            for row in observations
+        )
+        and observations[0]["sampled"] == [1, 2]
+        and observations[-1]["sampled"] == [1, 2]
+    )
+    if not passed:
+        raise RuntimeError(
+            f"synthetic inverse-CDF sampler test failed: {observations}"
+        )
+    return {
+        "passed": True,
+        "temperature": TEMPERATURE,
+        "top_p": TOP_P,
+        "observations": observations,
+    }
+
+
+def prepare_sources(
+    args: argparse.Namespace,
+    tokenizer: Any,
+    manifest: dict[str, Any],
+) -> tuple[list[dict[str, Any]], dict[str, Any], dict[str, Any]]:
+    args.domains = list(DOMAINS)
+    args.per_domain = 32
+    source_rows, reference = behavior.selected_sources(args, tokenizer)
+    manifest_rows = {
+        row["id"]: row for row in manifest["sources"]
+    }
+    audit_rows = []
+    for source in source_rows:
+        source["variants"] = {
+            condition: special.prior.render_boundary_variant(
+                tokenizer,
+                source["content"],
+                condition,
+            )
+            for condition in CONDITIONS
+        }
+        frozen = manifest_rows.get(source["id"])
+        if frozen is None:
+            raise RuntimeError(
+                f"{source['id']} is absent from frozen manifest"
+            )
+        if (
+            frozen["domain"] != source["domain"]
+            or frozen["domain_index"] != source["within_domain_index"]
+            or frozen["source_text_sha256"]
+            != source["source_text_sha256"]
+        ):
+            raise RuntimeError(
+                f"{source['id']} source contract differs"
+            )
+        for condition in CONDITIONS:
+            observed = source["variants"][condition][
+                "token_ids_sha256"
+            ]
+            expected = frozen[
+                "chat_generation_prompt_token_ids_sha256"
+            ][
+                condition
+            ]
+            audit_rows.append(
+                {
+                    "source_id": source["id"],
+                    "domain": source["domain"],
+                    "domain_index": source["within_domain_index"],
+                    "condition": condition,
+                    "observed_sha256": observed,
+                    "manifest_sha256": expected,
+                    "exact": observed == expected,
+                }
+            )
+    mismatches = [row for row in audit_rows if not row["exact"]]
+    if mismatches:
+        raise RuntimeError(
+            f"{len(mismatches)} prompt hashes differ from manifest"
+        )
+    if len(audit_rows) != 256:
+        raise RuntimeError(
+            f"expected 256 prompt audit rows, got {len(audit_rows)}"
+        )
+    return source_rows, reference, {
+        "cells": len(audit_rows),
+        "exact": sum(row["exact"] for row in audit_rows),
+        "rows": audit_rows,
+    }
+
+
+def execution_assignment(
+    *,
+    mode: str,
+    source_rows: list[dict[str, Any]],
+    manifest: dict[str, Any],
+) -> list[tuple[dict[str, Any], list[str]]]:
+    frozen = {row["id"]: row for row in manifest["sources"]}
+    assignment = []
+    for source in source_rows:
+        row = frozen[source["id"]]
+        if mode == "formal":
+            tapes = [*row["main_tapes"], *row["diagnostic_tapes"]]
+        elif mode == "replay":
+            tapes = ["T0"] if row["independent_replay"] else []
+        else:
+            tapes = (
+                ["T0", "T1"]
+                if row["domain_index"]
+                in manifest["tape_contract"][
+                    "diagnostic_source_indices_per_domain"
+                ]
+                else []
+            )
+        if tapes:
+            assignment.append((source, tapes))
+    expected = {"formal": (64, 88), "replay": (16, 16), "smoke": (8, 16)}
+    observed = (
+        len(assignment),
+        sum(len(tapes) for _, tapes in assignment),
+    )
+    if observed != expected[mode]:
+        raise RuntimeError(
+            f"{mode} assignment is {observed}, expected {expected[mode]}"
+        )
+    return assignment
+
+
+def prepare_batch(
+    source: dict[str, Any],
+    tokenizer: Any,
+    input_device: torch.device,
+) -> dict[str, Any]:
+    unpadded = [
+        source["variants"][condition]["token_ids"]
+        for condition in CONDITIONS
+    ]
+    prompt_lengths = [len(row) for row in unpadded]
+    batch_prompt_length = max(prompt_lengths)
+    padded = [
+        [int(tokenizer.pad_token_id)]
+        * (batch_prompt_length - len(row))
+        + row
+        for row in unpadded
+    ]
+    masks = [
+        [0] * (batch_prompt_length - len(row))
+        + [1] * len(row)
+        for row in unpadded
+    ]
+    return {
+        "input_ids": torch.tensor(
+            padded,
+            dtype=torch.long,
+            device=input_device,
+        ),
+        "attention_mask": torch.tensor(
+            masks,
+            dtype=torch.long,
+            device=input_device,
+        ),
+        "prompt_lengths": prompt_lengths,
+        "batch_prompt_length": batch_prompt_length,
+    }
+
+
+def derive_run_seed(tape: str, source_id: str) -> int:
+    payload = (
+        f"{PROTOCOL_ID}/run\0{tape}\0{source_id}"
+    ).encode()
+    value = int.from_bytes(
+        hashlib.sha256(payload).digest()[:8],
+        "big",
+    )
+    return value % ((1 << 63) - 1)
+
+
+def generate_tape(
+    *,
+    source: dict[str, Any],
+    tape: dict[str, Any],
+    batch: dict[str, Any],
+    model: Any,
+    tokenizer: Any,
+    gold: dict[str, dict[str, Any]],
+    max_new_tokens: int,
+) -> dict[str, Any]:
+    tape_label = tape["label"]
+    run_seed = derive_run_seed(tape_label, source["id"])
+    rng_before = sampling.set_run_seed(run_seed)
+    if torch.cuda.is_available():
+        torch.cuda.reset_peak_memory_stats()
+        torch.cuda.synchronize()
+    started = time.perf_counter()
+    input_ids = batch["input_ids"]
+    attention_mask = batch["attention_mask"]
+    generated_ids: list[list[int]] = [
+        [] for _ in CONDITIONS
+    ]
+    active = [True for _ in CONDITIONS]
+    uniform_uint64: list[int] = []
+    uniform_float32_values: list[float] = []
+    finite_token_ranges: list[tuple[int, int]] = []
+    past_key_values = None
+    temperature_warper = TemperatureLogitsWarper(TEMPERATURE)
+    top_p_warper = TopPLogitsWarper(
+        TOP_P,
+        min_tokens_to_keep=1,
+    )
+
+    with torch.inference_mode():
+        for step in range(max_new_tokens):
+            model_inputs = model.prepare_inputs_for_generation(
+                input_ids,
+                past_key_values=past_key_values,
+                attention_mask=attention_mask,
+                use_cache=True,
+            )
+            outputs = model(**model_inputs, return_dict=True)
+            past_key_values = outputs.past_key_values
+            logits = outputs.logits[:, -1, :]
+            z_value = tape_uint64(
+                tape_label,
+                source["id"],
+                step,
+            )
+            uniform = uniform_float32(
+                z_value,
+                device=logits.device,
+            )
+            sampled, step_audit = inverse_cdf_sample(
+                input_ids=input_ids,
+                logits=logits,
+                uniform=uniform,
+                temperature_warper=temperature_warper,
+                top_p_warper=top_p_warper,
+            )
+            sampled_ids = sampled.detach().cpu().tolist()
+            active_before = list(active)
+            uniform_uint64.append(z_value)
+            uniform_float32_values.append(float(uniform.item()))
+            finite_counts = step_audit["finite_tokens_per_row"]
+            finite_token_ranges.append(
+                (min(finite_counts), max(finite_counts))
+            )
+            next_for_model = []
+            next_mask = []
+            for row_index, is_active in enumerate(active_before):
+                if is_active:
+                    token_id = int(sampled_ids[row_index])
+                    generated_ids[row_index].append(token_id)
+                    next_for_model.append(token_id)
+                    next_mask.append(1)
+                    if token_id == int(tokenizer.eos_token_id):
+                        active[row_index] = False
+                else:
+                    next_for_model.append(int(tokenizer.pad_token_id))
+                    next_mask.append(0)
+            if not any(active) or step + 1 == max_new_tokens:
+                break
+            input_ids = torch.cat(
+                [
+                    input_ids,
+                    torch.tensor(
+                        next_for_model,
+                        dtype=torch.long,
+                        device=input_ids.device,
+                    ).unsqueeze(-1),
+                ],
+                dim=-1,
+            )
+            attention_mask = torch.cat(
+                [
+                    attention_mask,
+                    torch.tensor(
+                        next_mask,
+                        dtype=torch.long,
+                        device=attention_mask.device,
+                    ).unsqueeze(-1),
+                ],
+                dim=-1,
+            )
+    del past_key_values
+    del outputs
+    if torch.cuda.is_available():
+        torch.cuda.synchronize()
+    elapsed = time.perf_counter() - started
+    rng_after = sampling.rng_snapshot()
+    peak_cuda = (
+        torch.cuda.max_memory_allocated()
+        if torch.cuda.is_available()
+        else None
+    )
+    if rng_before != rng_after:
+        raise RuntimeError(
+            f"{source['id']}/{tape_label}: inference consumed torch RNG"
+        )
+
+    output_rows = []
+    for row_index, condition in enumerate(CONDITIONS):
+        token_ids = generated_ids[row_index]
+        hit_eos = bool(
+            token_ids
+            and token_ids[-1] == int(tokenizer.eos_token_id)
+        )
+        text = tokenizer.decode(
+            token_ids,
+            skip_special_tokens=True,
+            clean_up_tokenization_spaces=False,
+        )
+        consumed_uniforms = uniform_uint64[: len(token_ids)]
+        output_rows.append(
+            {
+                "condition": condition,
+                "factors": special.FACTORS[condition],
+                "prompt_tokens": batch["prompt_lengths"][row_index],
+                "left_padding_tokens": (
+                    batch["batch_prompt_length"]
+                    - batch["prompt_lengths"][row_index]
+                ),
+                "prompt_token_ids_sha256": source["variants"][
+                    condition
+                ]["token_ids_sha256"],
+                "generated_tokens": len(token_ids),
+                "generated_token_ids": token_ids,
+                "generated_token_ids_sha256": canonical_hash(token_ids),
+                "hit_eos": hit_eos,
+                "stopped_at_max_new_tokens": (
+                    not hit_eos
+                    and len(token_ids) == max_new_tokens
+                ),
+                "text": text,
+                "text_sha256": sha256_bytes(text.encode()),
+                "uniform_steps_consumed": len(consumed_uniforms),
+                "uniform_uint64_prefix_sha256": canonical_hash(
+                    consumed_uniforms
+                ),
+                "uniform_uint64_first_eight_hex": [
+                    f"{value:016x}"
+                    for value in consumed_uniforms[:8]
+                ],
+                "task_score": behavior.task_score(
+                    source["domain"],
+                    source["id"],
+                    text,
+                    gold,
+                ),
+            }
+        )
+    return {
+        "replicate_index": tape["index"],
+        "replicate_label": tape_label,
+        "tape_label": tape_label,
+        "base_seed": tape["display_seed"],
+        "run_seed": run_seed,
+        "run_seed_used_only_for_rng_nonconsumption_audit": True,
+        "rng_state_before": rng_before,
+        "rng_state_after": rng_after,
+        "torch_rng_unchanged": True,
+        "uniform_steps_available": len(uniform_uint64),
+        "uniform_uint64_sha256": canonical_hash(uniform_uint64),
+        "uniform_uint64_first_eight_hex": [
+            f"{value:016x}" for value in uniform_uint64[:8]
+        ],
+        "uniform_float32_first_eight": uniform_float32_values[:8],
+        "finite_tokens_per_step_min": min(
+            value[0] for value in finite_token_ranges
+        ),
+        "finite_tokens_per_step_max": max(
+            value[1] for value in finite_token_ranges
+        ),
+        "generation_seconds": elapsed,
+        "peak_cuda_memory_allocated_bytes": peak_cuda,
+        "outputs": output_rows,
+    }
+
+
+def compare_runs(
+    left: dict[str, Any],
+    right: dict[str, Any],
+) -> dict[str, Any]:
+    rows = []
+    for left_output, right_output in zip(
+        left["outputs"],
+        right["outputs"],
+        strict=True,
+    ):
+        checks = {
+            "prompt_hash_exact": (
+                left_output["prompt_token_ids_sha256"]
+                == right_output["prompt_token_ids_sha256"]
+            ),
+            "uniform_hash_exact": (
+                left_output["uniform_uint64_prefix_sha256"]
+                == right_output["uniform_uint64_prefix_sha256"]
+            ),
+            "generated_token_ids_exact": (
+                left_output["generated_token_ids"]
+                == right_output["generated_token_ids"]
+            ),
+            "text_exact": (
+                left_output["text"] == right_output["text"]
+            ),
+            "stop_state_exact": (
+                left_output["hit_eos"] == right_output["hit_eos"]
+                and left_output["stopped_at_max_new_tokens"]
+                == right_output["stopped_at_max_new_tokens"]
+            ),
+            "rng_pre_state_exact": (
+                left["rng_state_before"]
+                == right["rng_state_before"]
+            ),
+        }
+        rows.append(
+            {
+                "condition": left_output["condition"],
+                **checks,
+                "all_exact": all(checks.values()),
+            }
+        )
+    return {
+        "cells": len(rows),
+        "all_exact": sum(row["all_exact"] for row in rows),
+        "rows": rows,
+        "passed": all(row["all_exact"] for row in rows),
+    }
+
+
+def journal_header(
+    *,
+    args: argparse.Namespace,
+    source: dict[str, Any],
+    tapes: list[str],
+    max_new_tokens: int,
+) -> dict[str, Any]:
+    return {
+        "protocol_id": PROTOCOL_ID,
+        "manifest_sha256": MANIFEST_SHA256,
+        "model_revision": behavior.MODEL_REVISION,
+        "execution_mode": args.execution_mode,
+        "source_id": source["id"],
+        "domain": source["domain"],
+        "domain_index": source["within_domain_index"],
+        "tapes": tapes,
+        "conditions": list(CONDITIONS),
+        "max_new_tokens": max_new_tokens,
+        "temperature": TEMPERATURE,
+        "top_p": TOP_P,
+        "top_k": TOP_K,
+    }
+
+
+def journal_path(
+    journal_dir: Path,
+    source: dict[str, Any],
+) -> Path:
+    safe_id = source["id"].replace("/", "-")
+    return (
+        journal_dir
+        / f"{source['domain']}-{source['within_domain_index']:02d}-{safe_id}.json"
+    )
+
+
+def load_journal(
+    path: Path,
+    expected_header: dict[str, Any],
+) -> dict[str, Any]:
+    payload = json.loads(path.read_text(encoding="utf-8"))
+    if payload.get("header") != expected_header:
+        raise RuntimeError(f"journal header differs: {path}")
+    source = payload.get("source")
+    if canonical_hash(source) != payload.get("source_sha256"):
+        raise RuntimeError(f"journal content hash differs: {path}")
+    return source
+
+
+def write_journal(
+    path: Path,
+    header: dict[str, Any],
+    source: dict[str, Any],
+) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    payload = {
+        "header": header,
+        "source_sha256": canonical_hash(source),
+        "source": source,
+    }
+    temporary = path.with_suffix(".tmp")
+    temporary.write_text(
+        json.dumps(payload, ensure_ascii=False, indent=2) + "\n",
+        encoding="utf-8",
+    )
+    os.replace(temporary, path)
+
+
+def summarize_sources(
+    sources: list[dict[str, Any]],
+) -> dict[str, Any]:
+    rows = [
+        output
+        for source in sources
+        for run in source["runs"]
+        for output in run["outputs"]
+    ]
+    replay = [
+        source["in_process_replay"]
+        for source in sources
+        if source.get("in_process_replay") is not None
+    ]
+    by_domain = {}
+    for domain in DOMAINS:
+        domain_rows = [
+            row
+            for source in sources
+            if source["domain"] == domain
+            for run in source["runs"]
+            for row in run["outputs"]
+        ]
+        by_domain[domain] = {
+            "sources": len(
+                {
+                    source["id"]
+                    for source in sources
+                    if source["domain"] == domain
+                }
+            ),
+            "outputs": len(domain_rows),
+            "natural_eos": sum(row["hit_eos"] for row in domain_rows),
+            "budget_truncated": sum(
+                row["stopped_at_max_new_tokens"]
+                for row in domain_rows
+            ),
+            "mean_generated_tokens": (
+                mean(row["generated_tokens"] for row in domain_rows)
+                if domain_rows
+                else None
+            ),
+        }
+    return {
+        "sources": len(sources),
+        "runs": sum(len(source["runs"]) for source in sources),
+        "outputs": len(rows),
+        "natural_eos": sum(row["hit_eos"] for row in rows),
+        "budget_truncated": sum(
+            row["stopped_at_max_new_tokens"] for row in rows
+        ),
+        "unique_generated_token_hashes": len(
+            {row["generated_token_ids_sha256"] for row in rows}
+        ),
+        "torch_rng_unchanged_runs": sum(
+            run["torch_rng_unchanged"]
+            for source in sources
+            for run in source["runs"]
+        ),
+        "in_process_replay": {
+            "sources": len(replay),
+            "cells": sum(row["cells"] for row in replay),
+            "all_exact": sum(row["all_exact"] for row in replay),
+            "passed": all(row["passed"] for row in replay)
+            if replay
+            else None,
+        },
+        "by_domain": by_domain,
+    }
+
+
+def main() -> None:
+    args = parse_args()
+    validate_args(args)
+    manifest = load_manifest(args)
+    install_condition_contract()
+    synthetic_test = synthetic_sampler_test()
+    max_new_tokens = (
+        SMOKE_MAX_NEW_TOKENS
+        if args.execution_mode == "smoke"
+        else FORMAL_MAX_NEW_TOKENS
+    )
+    captured_at = args.captured_at or datetime.now(
+        timezone.utc
+    ).isoformat()
+    revision_contract = behavior.download_revision_contract(
+        args.artifact_dir
+    )
+    official_generation = json.loads(
+        (args.artifact_dir / "generation_config.json").read_text(
+            encoding="utf-8"
+        )
+    )
+    expected_official = {
+        "do_sample": True,
+        "temperature": TEMPERATURE,
+        "top_p": TOP_P,
+        "bos_token_id": 100000,
+        "eos_token_id": 100001,
+    }
+    mismatches = {
+        key: {
+            "expected": expected,
+            "observed": official_generation.get(key),
+        }
+        for key, expected in expected_official.items()
+        if official_generation.get(key) != expected
+    }
+    if mismatches:
+        raise RuntimeError(
+            f"official generation config drifted: {mismatches}"
+        )
+
+    tokenizer = AutoTokenizer.from_pretrained(
+        args.artifact_dir,
+        trust_remote_code=True,
+        local_files_only=True,
+        use_fast=True,
+    )
+    if tokenizer.pad_token_id is None:
+        tokenizer.pad_token_id = tokenizer.eos_token_id
+    boundary_ids = special.special_family_token_ids(tokenizer)
+    if boundary_ids != {
+        "eos": 100001,
+        "bos": 100000,
+        "x": 87,
+        "period": 13,
+    }:
+        raise RuntimeError(
+            f"unexpected pinned tokenizer IDs: {boundary_ids}"
+        )
+    source_rows, reference, prompt_audit = prepare_sources(
+        args,
+        tokenizer,
+        manifest,
+    )
+    assignment = execution_assignment(
+        mode=args.execution_mode,
+        source_rows=source_rows,
+        manifest=manifest,
+    )
+    gold = behavior.load_gold(args)
+    tape_index = {
+        row["label"]: row
+        for row in manifest["tape_contract"]["tapes"]
+    }
+
+    generated_sources = []
+    pending = []
+    for source, tapes in assignment:
+        header = journal_header(
+            args=args,
+            source=source,
+            tapes=tapes,
+            max_new_tokens=max_new_tokens,
+        )
+        path = (
+            journal_path(args.journal_dir, source)
+            if args.journal_dir is not None
+            else None
+        )
+        if (
+            path is not None
+            and path.is_file()
+            and args.resume
+        ):
+            generated_sources.append(load_journal(path, header))
+        else:
+            pending.append((source, tapes, header, path))
+
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+        torch.cuda.reset_peak_memory_stats()
+        torch.cuda.synchronize()
+    load_started = time.perf_counter()
+    _, official_modeling = special.base.load_official_modules(
+        args.artifact_dir
+    )
+    model = official_modeling.DeepseekV2ForCausalLM.from_pretrained(
+        args.artifact_dir,
+        local_files_only=True,
+        torch_dtype=torch.bfloat16,
+        low_cpu_mem_usage=True,
+        device_map="auto",
+        max_memory={
+            0: args.gpu_memory,
+            "cpu": args.cpu_memory,
+        },
+    )
+    model.eval()
+    if torch.cuda.is_available():
+        torch.cuda.synchronize()
+    load_seconds = time.perf_counter() - load_started
+    load_peak_cuda = (
+        torch.cuda.max_memory_allocated()
+        if torch.cuda.is_available()
+        else None
+    )
+    cuda_after_load = (
+        torch.cuda.memory_allocated()
+        if torch.cuda.is_available()
+        else None
+    )
+    input_device = model.get_input_embeddings().weight.device
+
+    for pending_index, (
+        source,
+        tapes,
+        header,
+        path,
+    ) in enumerate(pending, start=1):
+        batch = prepare_batch(source, tokenizer, input_device)
+        runs = [
+            generate_tape(
+                source=source,
+                tape=tape_index[tape],
+                batch=batch,
+                model=model,
+                tokenizer=tokenizer,
+                gold=gold,
+                max_new_tokens=max_new_tokens,
+            )
+            for tape in tapes
+        ]
+        replay = None
+        if args.execution_mode == "smoke":
+            replay_run = generate_tape(
+                source=source,
+                tape=tape_index["T0"],
+                batch=batch,
+                model=model,
+                tokenizer=tokenizer,
+                gold=gold,
+                max_new_tokens=max_new_tokens,
+            )
+            replay = compare_runs(runs[0], replay_run)
+            if not replay["passed"]:
+                raise RuntimeError(
+                    f"{source['id']}: smoke replay failed"
+                )
+        generated = {
+            key: value
+            for key, value in source.items()
+            if key not in {"content", "variants"}
+        } | {
+            "prompt_tokens_by_condition": {
+                condition: batch["prompt_lengths"][index]
+                for index, condition in enumerate(CONDITIONS)
+            },
+            "batch_prompt_tokens_after_left_padding": batch[
+                "batch_prompt_length"
+            ],
+            "batch_padding_side": "left",
+            "batch_conditions": len(CONDITIONS),
+            "runs": runs,
+            "in_process_replay": replay,
+        }
+        generated_sources.append(generated)
+        if path is not None:
+            write_journal(path, header, generated)
+        print(
+            json.dumps(
+                {
+                    "progress": f"{pending_index}/{len(pending)}",
+                    "source_id": source["id"],
+                    "tapes": tapes,
+                    "outputs": len(runs) * len(CONDITIONS),
+                    "seconds": sum(
+                        run["generation_seconds"] for run in runs
+                    ),
+                    "journal": str(path) if path else None,
+                },
+                ensure_ascii=False,
+            ),
+            flush=True,
+        )
+
+    generated_sources.sort(
+        key=lambda source: (
+            DOMAINS.index(source["domain"]),
+            source["within_domain_index"],
+        )
+    )
+    summary = summarize_sources(generated_sources)
+    expected_outputs = {
+        "smoke": 64,
+        "formal": 352,
+        "replay": 64,
+    }[args.execution_mode]
+    if summary["outputs"] != expected_outputs:
+        raise RuntimeError(
+            f"observed {summary['outputs']} outputs, "
+            f"expected {expected_outputs}"
+        )
+    if args.execution_mode == "smoke":
+        first_by_source_condition = {}
+        for source in generated_sources:
+            for run in source["runs"]:
+                for output in run["outputs"]:
+                    first_by_source_condition[
+                        (
+                            source["id"],
+                            run["tape_label"],
+                            output["condition"],
+                        )
+                    ] = output["generated_token_ids"]
+        divergent = sum(
+            first_by_source_condition[
+                (source["id"], "T0", condition)
+            ]
+            != first_by_source_condition[
+                (source["id"], "T1", condition)
+            ]
+            for source in generated_sources
+            for condition in CONDITIONS
+        )
+        summary["smoke_tape_divergence"] = {
+            "cells": len(generated_sources) * len(CONDITIONS),
+            "different_trajectories": divergent,
+            "passed": divergent > 0,
+        }
+        if not summary["smoke_tape_divergence"]["passed"]:
+            raise RuntimeError("T0/T1 smoke divergence gate failed")
+        if (
+            prompt_audit["exact"] != 256
+            or summary["torch_rng_unchanged_runs"]
+            != summary["runs"]
+            or not summary["in_process_replay"]["passed"]
+        ):
+            raise RuntimeError("smoke audit gate failed")
+
+    device_map = getattr(model, "hf_device_map", {})
+    parameter_bytes: dict[str, int] = {}
+    parameter_bytes_by_dtype: dict[str, int] = {}
+    for parameter in model.parameters():
+        device = str(parameter.device)
+        parameter_bytes[device] = (
+            parameter_bytes.get(device, 0)
+            + parameter.numel() * parameter.element_size()
+        )
+        dtype = str(parameter.dtype)
+        parameter_bytes_by_dtype[dtype] = (
+            parameter_bytes_by_dtype.get(dtype, 0)
+            + parameter.numel() * parameter.element_size()
+        )
+    checkpoint_index = json.loads(
+        (
+            args.artifact_dir / "model.safetensors.index.json"
+        ).read_text(encoding="utf-8")
+    )
+    checkpoint_tensor_bytes = int(
+        checkpoint_index["metadata"]["total_size"]
+    )
+    if sum(parameter_bytes.values()) != checkpoint_tensor_bytes:
+        raise RuntimeError(
+            "runtime parameter bytes do not match checkpoint index"
+        )
+    generation_peaks = [
+        run["peak_cuda_memory_allocated_bytes"]
+        for source in generated_sources
+        for run in source["runs"]
+        if run["peak_cuda_memory_allocated_bytes"] is not None
+    ]
+    peak_cuda = (
+        max([load_peak_cuda, *generation_peaks])
+        if load_peak_cuda is not None
+        else None
+    )
+    logits_process_path = Path(
+        transformers.generation.logits_process.__file__
+    )
+    executed_tapes = sorted(
+        {
+            run["tape_label"]
+            for source in generated_sources
+            for run in source["runs"]
+        }
+    )
+    result = {
+        "schema_version": 1,
+        "protocol_id": PROTOCOL_ID,
+        "execution_mode": args.execution_mode,
+        "captured_at": captured_at,
+        "model": {
+            "repo": "deepseek-ai/DeepSeek-V2-Lite-Chat",
+            "revision": behavior.MODEL_REVISION,
+            "checkpoint_identity": "SFT Chat",
+            "architecture": type(model).__name__,
+            "dtype": "bfloat16",
+            "checkpoint_tensor_bytes": checkpoint_tensor_bytes,
+            "download_revision_contract": revision_contract,
+            "files": {
+                name: {
+                    "bytes": (args.artifact_dir / name).stat().st_size,
+                    "sha256": behavior.sha256(
+                        args.artifact_dir / name
+                    ),
+                }
+                for name in behavior.MODEL_FILES
+            },
+        },
+        "tokenizer_contract": {
+            "length": len(tokenizer),
+            "vocab_size": tokenizer.vocab_size,
+            "all_special_tokens": tokenizer.all_special_tokens,
+            "all_special_ids": tokenizer.all_special_ids,
+            "boundary_token_ids": boundary_ids,
+            "pad_token_id": tokenizer.pad_token_id,
+            "pad_aliases_eos": (
+                tokenizer.pad_token_id == tokenizer.eos_token_id
+            ),
+        },
+        "source_contract": {
+            **reference,
+            "manifest_path": str(args.manifest),
+            "manifest_sha256": MANIFEST_SHA256,
+            "domains": list(DOMAINS),
+            "frozen_per_domain": 32,
+            "executed_sources": len(generated_sources),
+            "full_source_text_used": True,
+            "prompt_hash_audit": prompt_audit,
+        },
+        "seed_contract": {
+            "protocol_id": PROTOCOL_ID,
+            "tape_derivation": manifest["tape_contract"],
+            "preregistered_base_seeds": [
+                tape["display_seed"]
+                for tape in manifest["tape_contract"]["tapes"]
+            ],
+            "executed_base_seeds": [
+                tape_index[label]["display_seed"]
+                for label in executed_tapes
+            ],
+            "executed_tapes": executed_tapes,
+            "condition_row_order": list(CONDITIONS),
+            "explicit_common_random_numbers": True,
+            "same_source_tape_step_same_uniform_across_conditions": True,
+            "torch_rng_used_for_sampling": False,
+            "torch_rng_normalized_only_for_nonconsumption_audit": True,
+        },
+        "generation_contract": {
+            "conditions": special.FACTORS,
+            "official_serialization": {
+                "eos": True,
+                "period": False,
+            },
+            "decode": (
+                "explicit-uniform inverse-CDF nucleus sampler in "
+                "token-ID order"
+            ),
+            "transformers_generate_called": False,
+            "torch_multinomial_called": False,
+            "distribution_temperature": TEMPERATURE,
+            "distribution_top_p": TOP_P,
+            "distribution_top_k": TOP_K,
+            "max_new_tokens": max_new_tokens,
+            "use_cache": True,
+            "softmax_dtype": "torch.float32",
+            "cdf_dtype": "torch.float32",
+            "uniform_dtype": "torch.float32",
+            "uniform_endpoint_clamp": (
+                "torch.nextafter(0,1) through torch.nextafter(1,0)"
+            ),
+            "cdf_final_value_forced_to_one": True,
+            "temperature_warper": (
+                "transformers.TemperatureLogitsWarper(0.3)"
+            ),
+            "top_p_warper": (
+                "transformers.TopPLogitsWarper("
+                "0.95,min_tokens_to_keep=1)"
+            ),
+            "all_conditions_same_source_batch": True,
+            "batch_conditions": len(CONDITIONS),
+            "finished_rows_append_pad_eos_with_attention_mask_zero": True,
+            "batch_padding": (
+                "left padding with PAD=EOS and attention_mask=0; "
+                "all prompt endpoints occupy the final prompt column"
+            ),
+            "official_generation_config": official_generation,
+            "official_sampling_parameters_define_distribution_only": True,
+            "counterfactual_boundary": (
+                "Period cells edit one pre-target token ID after "
+                "official rendering and are not valid official chats."
+            ),
+            "synthetic_sampler_test": synthetic_test,
+        },
+        "execution": {
+            "python": platform.python_version(),
+            "torch": torch.__version__,
+            "transformers": transformers.__version__,
+            "accelerate": accelerate.__version__,
+            "safetensors": safetensors.__version__,
+            "platform": platform.platform(),
+            "gpu": (
+                torch.cuda.get_device_name(0)
+                if torch.cuda.is_available()
+                else None
+            ),
+            "gpu_memory_limit": args.gpu_memory,
+            "cpu_memory_limit": args.cpu_memory,
+            "pytorch_cuda_alloc_conf": os.environ.get(
+                "PYTORCH_CUDA_ALLOC_CONF"
+            ),
+            "input_device": str(input_device),
+            "device_map": device_map,
+            "parameter_bytes_by_runtime_parameter_device": (
+                parameter_bytes
+            ),
+            "parameter_bytes_by_dtype": parameter_bytes_by_dtype,
+            "load_seconds": load_seconds,
+            "load_peak_cuda_memory_allocated_bytes": load_peak_cuda,
+            "cuda_memory_allocated_after_load_bytes": cuda_after_load,
+            "peak_cuda_memory_allocated_bytes": peak_cuda,
+            "process_max_rss_kib": resource.getrusage(
+                resource.RUSAGE_SELF
+            ).ru_maxrss,
+            "transformers_logits_process_path": str(
+                logits_process_path
+            ),
+            "transformers_logits_process_sha256": behavior.sha256(
+                logits_process_path
+            ),
+            "official_single_gpu_bf16_requirement": "40GB GPU",
+            "local_single_gpu_capacity_mib": 32607,
+            "offload_required_by_local_capacity": True,
+            "journal_dir": (
+                str(args.journal_dir)
+                if args.journal_dir is not None
+                else None
+            ),
+            "resumed_sources": len(generated_sources) - len(pending),
+        },
+        "sources": generated_sources,
+        "summary": summary,
+        "claim_boundary": [
+            "HumanEval and GSM8K are analyzed separately.",
+            (
+                "The main estimand is scoped to the frozen 32 selected "
+                "tasks per domain under tape T0."
+            ),
+            (
+                "Selected-task bootstrap bands are not benchmark-"
+                "population, model-ability, or seed-uncertainty intervals."
+            ),
+            (
+                "The explicit inverse-CDF sampler uses the official "
+                "temperature/top-p distribution but is not the exact "
+                "Transformers torch.multinomial trajectory."
+            ),
+            "Counterfactual period sequences are not official-valid chats.",
+            "Passing HumanEval tests is functional, not safety, evidence.",
+            "CPU-offloaded eager latency is not serving throughput.",
+        ],
+    }
+    result["content_hash"] = canonical_hash(
+        {
+            "protocol_id": result["protocol_id"],
+            "generation_contract": result["generation_contract"],
+            "sources": result["sources"],
+        }
+    )
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_text(
+        json.dumps(result, ensure_ascii=False, indent=2) + "\n",
+        encoding="utf-8",
+    )
+    payload = args.output.read_bytes()
+    print(
+        json.dumps(
+            {
+                "output": str(args.output),
+                "sha256": sha256_bytes(payload),
+                "bytes": len(payload),
+                "sources": len(generated_sources),
+                "outputs": summary["outputs"],
+                "load_seconds": load_seconds,
+                "generation_seconds": sum(
+                    run["generation_seconds"]
+                    for source in generated_sources
+                    for run in source["runs"]
+                ),
+                "peak_cuda_memory_allocated_bytes": peak_cuda,
+                "summary": summary,
+            },
+            ensure_ascii=False,
+            indent=2,
+        )
+    )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/research/DEEPSEEK_V2_LITE_CHAT_TASK_BOOTSTRAP_MANIFEST.json b/research/DEEPSEEK_V2_LITE_CHAT_TASK_BOOTSTRAP_MANIFEST.json
index 17208f8..eee6f1c 100644
--- a/research/DEEPSEEK_V2_LITE_CHAT_TASK_BOOTSTRAP_MANIFEST.json
+++ b/research/DEEPSEEK_V2_LITE_CHAT_TASK_BOOTSTRAP_MANIFEST.json
@@ -1,7 +1,7 @@
 {
   "schema_version": 1,
   "protocol_id": "llm-atlas-deepseek-chat-task-bootstrap-crn-v1",
-  "status": "preregistered_before_any_protocol_output",
+  "status": "preregistered_and_chat_prompt_hashes_corrected_before_any_protocol_output",
   "source_reference": {
     "path": "src/data/deepseek-v2-lite-routing-special-token-family-control.json",
     "sha256": "c372c1b03a8b15f615b54ded5d9257a8fc2cdb7728001735d3d4c1d8534af5bf",
@@ -29,7 +29,7 @@
       "domain_index": 0,
       "selection_rank": "004f4cfa62936a4a096e53df7d0ef3926c3ee97d32cf67a3c9bd64569f580e5c",
       "source_text_sha256": "b7e32acf5a6b551a782eacfb4ecab09e59f0577a2da9642e292d2479af5bf50e",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "7b77b4577b783e49ff43d4c2187d0351070e82d9f7ad6407d456e710997d341a",
         "s1_eos": "692fe7aa84f0d62d4706eb2c07f7c87602e13a16b2ea4753b277222bd9c2cd27",
         "s0_period": "421b6cfe57a7662ce1c9fecb7761f01a723fbddae6956634deef5b0c855c0ca0",
@@ -43,7 +43,19 @@
         "T2",
         "T3"
       ],
-      "independent_replay": true
+      "independent_replay": true,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "6be7e854ac1a52102505446e011621de1eb53890d8bb05e6da6acc04b8aba862",
+        "s1_eos": "c6783406e90bf388721019684ddad1e7fb00ae8d7e28588fedc2098130fcfbe9",
+        "s0_period": "28a248f8e6baf3e910836ec1212882afd51ccef972a30d6306f604cd3fd10a10",
+        "s1_period": "60e9d47943e9ba8869476dcc61e1a943b7e2dcf88d1d7334c44267baa5a8fd5f"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 145,
+        "s1_eos": 161,
+        "s0_period": 145,
+        "s1_period": 161
+      }
     },
     {
       "id": "HumanEval/44",
@@ -51,7 +63,7 @@
       "domain_index": 1,
       "selection_rank": "030cfc7acc71ac4484d25020b2f340973c6cd1e20c2bdb1b3be9d532032eaa24",
       "source_text_sha256": "70a0af759ec21f43ca0d40f7b7a3ec39e32388c9b5416fe06e5c658ce89e6666",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "d307dd3753328321025f1c4f7daed99d8112cdbaece9ae5c4e9434ec0be99bea",
         "s1_eos": "08438585e3cf69835d23eeb8ab6f1090d12c4f84f8b0565522bc2da770b5e044",
         "s0_period": "113b960a9ba5cb68975b9525955d3c500de2a9e7dac65516d905ee47526ce4e9",
@@ -61,7 +73,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "34636650c2d01d108c0812d19c1b7832fc580fe1251ae8d9fa905b5a0c3dc85b",
+        "s1_eos": "8064601979f18146c339c546016365833f2ca0d6c99b504906e55b54d5a4a7e4",
+        "s0_period": "e71413377a91a13f6e6add6206927e67c2f744738c6124a22048f67a2fb45266",
+        "s1_period": "4a47efad70aed38e5a3f4ec519584f08d4e9cd89a12fbc9ee9b1f1ee206a651b"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 133,
+        "s1_eos": 149,
+        "s0_period": 133,
+        "s1_period": 149
+      }
     },
     {
       "id": "HumanEval/133",
@@ -69,7 +93,7 @@
       "domain_index": 2,
       "selection_rank": "03661faa70d0db8ba0c1d391356f9c7cdb8f50ccbeedc0911f6b2a3be0190ed3",
       "source_text_sha256": "8c46f1b09d1a8179497c272a2597766eb2a53fbd00cb8cdd8a8446e547103a13",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "eff8116b77e3d06fb232cfb8d6eeb50a596d65d6d1b36793dbf64ccb6e60cb89",
         "s1_eos": "8a62de2d1348a57470e6b2fbf13ff05e92df2beb736f6c395645b1f725255306",
         "s0_period": "de16ffc772f59282841164b0f63a3123ea9f4afa611b957da7dd22e5738e79a3",
@@ -79,7 +103,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "7b84065a1b5a2ed75dc3a7b4946b265f6ddc8294e89dfc581c7da9b0cc5a938c",
+        "s1_eos": "e4276f9ff4296a6c846b43bbc3fa2221ec810ffd93bb6b2222e1f3a3228422a0",
+        "s0_period": "5e556876b30e7de83e1d58a9331853ee7adff92957c6421cf176331235fe7f80",
+        "s1_period": "537648bc701d6509e6c7925284b842e598400c662918f3b2319d0e54a404019c"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 191,
+        "s1_eos": 207,
+        "s0_period": 191,
+        "s1_period": 207
+      }
     },
     {
       "id": "HumanEval/23",
@@ -87,7 +123,7 @@
       "domain_index": 3,
       "selection_rank": "03b3c7329e474bf8e9660969ed5898d561e718f12a59d2fc1ed641be54b68860",
       "source_text_sha256": "0bb479f80d27872f6bebc01618112b372cc8a2e6aee9e4b76337e3b3416418c7",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "44f56cefedb9e06886f39ae8d3cb2dc2fbf272474cfe90f674c27903cd9260f7",
         "s1_eos": "ccfd99b2ec8a496df3f757f161a19c5c12b510c89c4d022d9ea60a1369d90750",
         "s0_period": "9b42bf10687a2d2bce7d8dbc9e9f7514e83f6d4eb7477db407154794f07eb39f",
@@ -97,7 +133,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "cb47bc5c0e78c4ab62201c207af6c0385abba0c85cc1a22c130a8b6a445a1116",
+        "s1_eos": "82597f376eaa8456e5ef6faa9ca76898c8a26dc24355f8548d4588aca4a36df0",
+        "s0_period": "2f54a215c9dbb510d46c5a9ec14a563ab2d8bcd06081a351221e49244ff23ee7",
+        "s1_period": "19eb1141be8bf17769a49defff6edd7401bce652f18c7df994b21151755aca3a"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 67,
+        "s1_eos": 83,
+        "s0_period": 67,
+        "s1_period": 83
+      }
     },
     {
       "id": "HumanEval/147",
@@ -105,7 +153,7 @@
       "domain_index": 4,
       "selection_rank": "05f542d26e3e5561da1a47e3b05d19f187ae9cd59e49ffb7a068f6bf89ddb892",
       "source_text_sha256": "d877205eaa6209a40f4f1c45755d9f04f038e64c49a366a08322a5111b05ae40",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "936dda23f081877f6e706ec1d1d65a132a787352fb1f0819de02f832602389a7",
         "s1_eos": "7731722269c215ebdf607875fdb77a59d3481c0de5d935191b027453ffd80bd1",
         "s0_period": "444f299cb5691cbe86e7fe70e7859b7175728d0c8b64c8cf23e6c78ad62e9de6",
@@ -115,7 +163,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": true
+      "independent_replay": true,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "5b27805a3da7e942ad07adf34a5632a627cdd949aa961a4a24680cfe67f99d92",
+        "s1_eos": "44e31b9bd850e04dc524a5087e67bc376f39039925cacda2af7eb27937d4a173",
+        "s0_period": "ec600c5ba2e9344a40d66fd2a9fd6a8b17c133af06e4a624b3fed14fe3105840",
+        "s1_period": "5562530a27f30d8a9d1e03593c6ba2813629a17924034ff1ac9f21b97b37e01b"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 212,
+        "s1_eos": 228,
+        "s0_period": 212,
+        "s1_period": 228
+      }
     },
     {
       "id": "HumanEval/34",
@@ -123,7 +183,7 @@
       "domain_index": 5,
       "selection_rank": "065d54b245ce523be85bc67060106d98536bacf8e862d709bc254ba6f24cca75",
       "source_text_sha256": "f3ad3f30094ecb6a48879e4b24e7e94112ca6c5e50fc82d98a4622f11d14839a",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "8c004a5eceb1743d097a8b3073ea6bc4638359c63a2d254b9a2d8df4554d76f4",
         "s1_eos": "59fa486fa217285d65df11f5db824be7d6680ef437379e31f6fc83acb6204ac6",
         "s0_period": "7cd611f6dee5f07d3f20c500091953cadddf5768247e544d4094aa5a8bac0b0b",
@@ -133,7 +193,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "50dfec49c50ffa67dcf9ba5b64cd01051513a2dffbec01918ff250d7ed295f0a",
+        "s1_eos": "d00be33d9e7ae1c889c85289fd49283adca47fb0a91682a5404b4ed50fb63742",
+        "s0_period": "a4825c06f634aa50e9db51a882f942d52931c7bbd6cccde21fdae6451316fb9f",
+        "s1_period": "23a584dae81780a044a3e648eaf768d7beb392399c5a27648c2e7e13f5b178b9"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 102,
+        "s1_eos": 118,
+        "s0_period": 102,
+        "s1_period": 118
+      }
     },
     {
       "id": "HumanEval/123",
@@ -141,7 +213,7 @@
       "domain_index": 6,
       "selection_rank": "0782f17352664fabe6a6a9e2bd72a83d60ba60aaaed7900593390e1f16d00241",
       "source_text_sha256": "b74013271763bb6e1b0f3a7cd6e2f489c5205edd219a55145ba2409b52cf2c44",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "153d82ed03de25c51393e3d5eb83ffdf1ff238d3c70f52c3bbb1bb21c3d26de9",
         "s1_eos": "1de21d2674032ed1caf812f40917bc3ed5053244ae265a515788f92271fd194a",
         "s0_period": "28564bef8d7b9c55fb0e67f4e1a17f1f509927aaf0022df66983eb0a7ea77f5e",
@@ -151,7 +223,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "57f64a403a7a39a898b1fe60b4a8ca3c14b7dd3762a0cef6db31242d2c196db5",
+        "s1_eos": "0ddfe78c3d19e7710c9ad95eb25f43b6ead61f695b223fa0f2eadeb70939b132",
+        "s0_period": "32aa1eeae28002e834b909a274e0a258a007494861bf6b87f2c0ddf36e3a2fc2",
+        "s1_period": "c6347070b53e3bb0eead067f235c8cc6e3a0850185320a8ebfa14b18fa2497b3"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 270,
+        "s1_eos": 286,
+        "s0_period": 270,
+        "s1_period": 286
+      }
     },
     {
       "id": "HumanEval/77",
@@ -159,7 +243,7 @@
       "domain_index": 7,
       "selection_rank": "080caedf33fbd9532bd76e2b8966df2f14fcca78e937976441b602e3a4374a53",
       "source_text_sha256": "44c77e3178c60f7a753765c62cf0edfdab0da4cc1b19b2ebd9cd88aad46729f5",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "daee0dfff5fddd485e3c889c4decbb6915ef82862eba61ecb72df985acfd16a7",
         "s1_eos": "5b426ad93113e0721440bf05460a5cb4fb99b93fb4595b9921063e908823ed67",
         "s0_period": "d9d41156b1bbadd7974085db0a24319fdfef160c8b42c5e06f6d9419342720de",
@@ -169,7 +253,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "e3183567ed5eb97a417231ff30787cda390ce6d1d6c619a9f96aca4431325ea7",
+        "s1_eos": "a82262f32e1016ad94607d11531b624bd291ccb41153070cef133add5a40e3b2",
+        "s0_period": "5cba1c1d5fafa1a4808f539d390e9527f839ff83eabc9c2473371904f174b8d3",
+        "s1_period": "0926d8ab839c31c12eff891112adc367bf0308b29578347e64ba687410ee3b31"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 140,
+        "s1_eos": 156,
+        "s0_period": 140,
+        "s1_period": 156
+      }
     },
     {
       "id": "HumanEval/22",
@@ -177,7 +273,7 @@
       "domain_index": 8,
       "selection_rank": "0a405335d6bb665be461ddda5d6e1ec3a7adef8e224bc35ab268d1851def9a54",
       "source_text_sha256": "45a5283612af3caab31e93add5e1b110b3616e6d61dd9c7d8f71bad625468b9d",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "d259f0ca39731ed364a920f618ede0fe59daf42561d2b4cfcc978f7323c852e0",
         "s1_eos": "c9f1f9e99f2760bf1ef1f940281489c4794ee218e1da67bef9a109aa51c7ec3d",
         "s0_period": "cdc178e573b59f0bd3a4df10cfa635c313c95c58ef30c894ab9a8e94460f6789",
@@ -191,7 +287,19 @@
         "T2",
         "T3"
       ],
-      "independent_replay": true
+      "independent_replay": true,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "99f8dfd93c18d95f8c946f222194a75d33d59b9c7c7e083a6529fded1e768650",
+        "s1_eos": "7691122ec2f8f733dc915a4f5c39ed11844344cb8ba4fe03d6618e40bfd2082f",
+        "s0_period": "3cfb93f9154faac528811f3f119081dc8fb77bc2562ea7fec6229f447344a156",
+        "s1_period": "be7f8eaaba596aeb1a26f1d04183f77cfa8b116679b9ebddb90601107b5d700a"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 123,
+        "s1_eos": 139,
+        "s0_period": 123,
+        "s1_period": 139
+      }
     },
     {
       "id": "HumanEval/127",
@@ -199,7 +307,7 @@
       "domain_index": 9,
       "selection_rank": "0abbfb91f73663bb04458c0b3cac62fbe2aaf3374b7ccb9b26b1e1db67a4d4d2",
       "source_text_sha256": "897803d2df27adaf9ee777c6b78f18fb771381928fbf2774e991411b15c340ad",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "b462b3f52193fe601d58f7efc9efc5bdd21df100b6cc91068e0bc7599f0e6296",
         "s1_eos": "2f55735917f9d5686b161b275f6482cea0da886a5b670a6d1dbb05d5ebbaec86",
         "s0_period": "565f7eddd88b6e6ebaf95704022b95850b17824947f7012fab46d9a0196ccd10",
@@ -209,7 +317,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "2ae6c31f9dcd004aa9ff4b75449dcd018c51f331c2bb65c87f70d4afc9c72675",
+        "s1_eos": "24ca147ea1e0fe2cd58f14f79b0580891e1f6e7cd56d4e268fdf32f8818850d8",
+        "s0_period": "571469a982ac199ac167fd7b209a159175b1313ac6f1a474767d83d65523fe30",
+        "s1_period": "402db0464530baf1a6d324bf16773846ecb8745b12cf991dcd69d364f07d8d18"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 297,
+        "s1_eos": 313,
+        "s0_period": 297,
+        "s1_period": 313
+      }
     },
     {
       "id": "HumanEval/37",
@@ -217,7 +337,7 @@
       "domain_index": 10,
       "selection_rank": "0c9e63208d91d58824926ce0f501a49a3e55deecc293d9ebac84afc9d16182dd",
       "source_text_sha256": "229eeb9f0db57f5c2dde0a63ddba58a271940904b663b063f5dd32d79d0d8bfe",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "bd85acb66072986828bf7fcdcc57db2e70ca73ba5b8d73c9e72315ba69797ce5",
         "s1_eos": "43b46fef3e583c653403e2c39eb60211e4c7a6fe17c99525bd2d3670e780edcf",
         "s0_period": "8bd1494d3c196c05063d1d23c1806a7ba1c771dee7422c7e807a4553062e7458",
@@ -227,7 +347,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "6c71ab20fb240318f9284a4246c2a1d98bcdd44b87138a7f80d8298f8640ddf7",
+        "s1_eos": "845ad5216e52e23789d949f67f07f4220bed3c5f172b249bc40a9d07133249a6",
+        "s0_period": "74ac85aeb890e0da38fa453e36fc6b3f7f9566b1dc11a442c062930eac20f965",
+        "s1_period": "9ea4e16fb5cb008d1aa94e97b7f154409c527df042459cae1b1c340fb1714d6f"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 154,
+        "s1_eos": 170,
+        "s0_period": 154,
+        "s1_period": 170
+      }
     },
     {
       "id": "HumanEval/48",
@@ -235,7 +367,7 @@
       "domain_index": 11,
       "selection_rank": "0df5efc67f743da62c6c8793675ebce590c03f71d978e95d04527ced80ab6069",
       "source_text_sha256": "66c7b9796a6cfafed4f62fd1e784483b287656c7a628d39582e747967349220d",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "5770afc438461941f106c8736e5c241a6dc743347f6f1e9c5d3f3ee44b96d678",
         "s1_eos": "76e83c1beb445d4f76d8f97697feeea7ec26ce70ba41434ce2a8ea609cbd69ba",
         "s0_period": "91608b62ed4f3b86fc2077421ea9fbbcfcf18f450d5f348f062877738812f505",
@@ -245,7 +377,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "0f12795689a1c235625a61969cb4cf5ae1173e8f1642418e7231b6be6eace098",
+        "s1_eos": "a69fb616e4189a48ce3e97aca61e67cb88f882332143d4e84505d18092b48371",
+        "s0_period": "6dc8993a610d275f86205ae51b5050a3206033379f14135be29a2db75a4e99b0",
+        "s1_period": "d047614740d0aed3dec70e04733d510f101589fcc9b2a64b61dc3f60caa6d46e"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 112,
+        "s1_eos": 128,
+        "s0_period": 112,
+        "s1_period": 128
+      }
     },
     {
       "id": "HumanEval/158",
@@ -253,7 +397,7 @@
       "domain_index": 12,
       "selection_rank": "0e666ab1219416c4d077a968c59fc89eb16d12432d4c2c211421e7675a6628e2",
       "source_text_sha256": "1c9d5c90e7f754d3ad264e0830f21e50f2f8c094dd52d16a61c9242f31ae7841",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "314c3ccd61fcd63856f2e8424d72c418f3cc7d305d44201ade899c194e497993",
         "s1_eos": "4a0664887d2809f5ec718fe0c13c23a650cb4e98cbdc923a6b76c4976be2205d",
         "s0_period": "2a5c60ec398252f0622263fe7984ecc108ee7568b133a5770e24b080449e7dc2",
@@ -263,7 +407,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": true
+      "independent_replay": true,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "9bbd7584072be1d2698fd08aeeeee05fd04510ecd738714d57a5bd84f3a0f7ba",
+        "s1_eos": "c2fecd49df755e8b67944b609dd4b5e730644e309714d7ad0979cc7eb55451a7",
+        "s0_period": "ee31bf95a32a07b957fa91a798847294e2682f8b6fdd3c1cdac207962f6e8ec5",
+        "s1_period": "5c4975cc9a74c18629c0aaf1fa5ab6a3236be6c55f391dc5f9e49ec1ccd83dd4"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 151,
+        "s1_eos": 167,
+        "s0_period": 151,
+        "s1_period": 167
+      }
     },
     {
       "id": "HumanEval/70",
@@ -271,7 +427,7 @@
       "domain_index": 13,
       "selection_rank": "0f95cd54ad35edad763ba9ff249081d4b0c422bc4379ca91ce3a8e608919b54c",
       "source_text_sha256": "a668134355e83438ba8e62cd1b442897d98d53cd5190932b73c948d1551d029b",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "3b4c780e966fe38eff8fbe400f04e5fedd19bd0a9c8b56386c6df454f8e4e5b0",
         "s1_eos": "90e4725519dafd9b93429119a5ae7ea25ede7917c2b5296eca93ab2e6459de68",
         "s0_period": "baf86285b628930addd3efb3ce74c06b2cf31589a24834d8582fa31ea09e6190",
@@ -281,7 +437,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "6d4ea1c240b1bbadbe2c9054d1df899824eb754b62b68409b75578f53a4da8a1",
+        "s1_eos": "06eabe886d19dac9445fac2b61760e2aa8afdb519128886ccc6b50c118d63f74",
+        "s0_period": "899b0b62095260a10044dc1addcedebc3b86c682da03e45ea0035f5bb3e6375e",
+        "s1_period": "d85fe6096153ebddbee72342cf970da35e8f0d25fe9b3eaef1ace4b67c9317a6"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 163,
+        "s1_eos": 179,
+        "s0_period": 163,
+        "s1_period": 179
+      }
     },
     {
       "id": "HumanEval/89",
@@ -289,7 +457,7 @@
       "domain_index": 14,
       "selection_rank": "10bd0378740e88d6557677c66806363a8ab113a310e775ca0820fa7478022d1e",
       "source_text_sha256": "1049c3240be776d403e64cd3b73857a6235f079d55024312ceea611853b6ea39",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "78a1a74505b355e8ac272d6d0e7393e2f4291195521c24cd12aa84c0d40d3932",
         "s1_eos": "800961bc065356f64281dfab75e73eec5eaaf54875339d73405a4fe91c1e2482",
         "s0_period": "55c56f5529a94ee972f831a4e1694db7ecb52e7542b5796018f3aa0716197b68",
@@ -299,7 +467,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "7fa19949e9a7e884ed3240c53e052a3ef7dda2af2fe77805c586979f75701fe1",
+        "s1_eos": "8f71e9635b900c4239ba17caddcf32b1db5bde3aa97d212593d53a1e25784bc4",
+        "s0_period": "0a3a849f8ef617b38e9707cef1fc1b98dc48360faf23d5f29d87f3035052acd2",
+        "s1_period": "ca12e44e8c21576931ce2c62975f91bda8723a382a94bed561f6abadd07777d8"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 141,
+        "s1_eos": 157,
+        "s0_period": 141,
+        "s1_period": 157
+      }
     },
     {
       "id": "HumanEval/9",
@@ -307,7 +487,7 @@
       "domain_index": 15,
       "selection_rank": "11e369155ebde83738eac8a74152f2d999a9d4a51b1813b7c8b790adb89c5131",
       "source_text_sha256": "706c5a34dddbfadfb6f6996b8224f7278f9687d562121b60730271d177e03d29",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "a35480bd447aef02d0cd01b915cf45d6d888327d5db81996bb0957a22804e1d6",
         "s1_eos": "cdd84214cef7754b686416420f6b143cec21c83d238c01102219a4e846bfa6c8",
         "s0_period": "901b7e97b26ad8551a40fd27cc2373b5ac60eaa8e1cb198baf5564b389fe1ba6",
@@ -317,7 +497,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "a440ea0c62846d775cdba25e19a14b3e0d3e8992af4015472df5c2e752f819da",
+        "s1_eos": "8184e96105479bd22c9a1190811a66dc907b566d7cc5d865e90714c4bddc3140",
+        "s0_period": "291c2ed1cb9da436089593aa753cb375638b9d53e5501178493a8dde34c0b986",
+        "s1_period": "99407e98c7466d740a08944eccb2ecb1a6e4d256d78950b963a4fdb7bf5f82df"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 129,
+        "s1_eos": 145,
+        "s0_period": 129,
+        "s1_period": 145
+      }
     },
     {
       "id": "HumanEval/53",
@@ -325,7 +517,7 @@
       "domain_index": 16,
       "selection_rank": "11fb0257fece6b5a2e3ebfad4f913edb55a12e308d703a29ecb51111007252d7",
       "source_text_sha256": "609eece5c26c4e3f26df35588daf4a78508df124f64799f17d0553b17bf2be63",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "a887f4b746abfed282612212f14dbbc8239dba7b71577ceb4185cd8ef9aa7920",
         "s1_eos": "fa7bf486291c89f98d6bc376bda54c7beefa31d3eee26bd0a71d858c71e84d1f",
         "s0_period": "69549e7ce68a8c18538b9c4e73722b41a90ce7ce30d4e68cb1d49e915d28c96d",
@@ -339,7 +531,19 @@
         "T2",
         "T3"
       ],
-      "independent_replay": true
+      "independent_replay": true,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "0b193aaf07fe7f97b6b991cc9f5ceea6b4dd2ce1647b22b562c8ff6e645f49c3",
+        "s1_eos": "7f940c04c638ecedb8a0b110cd4c8fbda36835d1034d50bf4f9ed58cb5deb480",
+        "s0_period": "ec54e0e01336904d56e9cc549161965f86745d0cd20077962b98e5c9cf832d37",
+        "s1_period": "77c3060afe3b490baabdcdb1e01d32f9978db8d9dd2737366022e3240e1bc48e"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 77,
+        "s1_eos": 93,
+        "s0_period": 77,
+        "s1_period": 93
+      }
     },
     {
       "id": "HumanEval/145",
@@ -347,7 +551,7 @@
       "domain_index": 17,
       "selection_rank": "1262afd7962fdb524bae1c88f4ea10ae7820dd4a7a04b7f978acce27f8545dfc",
       "source_text_sha256": "8dd398d709ed6d32a38ba15a1a4bb882b08ee0637b397c5b8426e7654825ed06",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "6328a259ec67ae02bd8d9b055fe9b587fe0a7930717facc1d600fbf60bdaa0b5",
         "s1_eos": "026e05eb4a37af766655aea6bbce07c3f2bc1760c85a6c9b54a93c9bce0b2b92",
         "s0_period": "759854e60527a65f28d60edb1efa9835f2c3d25f84a1ca3087f747eb9ed9d2b3",
@@ -357,7 +561,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "58c6870be70d4c91e18370567042c8f5ed482cee461b46b61303a7e6e76183ad",
+        "s1_eos": "b4a014a3d98099104d7f7534f72de5186826a80c4a17df84c03e0170d267b519",
+        "s0_period": "e6fae0b7d45ce67996a870d0e0f8679abe430f7ce8f59f2f24076fd76256749a",
+        "s1_period": "158c23a00488eacf5f42031f771a65314f33e3a130a4ba87df78ed67963b86d6"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 158,
+        "s1_eos": 174,
+        "s0_period": 158,
+        "s1_period": 174
+      }
     },
     {
       "id": "HumanEval/35",
@@ -365,7 +581,7 @@
       "domain_index": 18,
       "selection_rank": "147ade420aa25ee992c940020f0100f2f637b102ce075d6659cac9e99aac5f38",
       "source_text_sha256": "f61f2f52f5962ff528b5fda83429b3a9da557e01877b49a0b622c199c0f78b5b",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "198a635f3ff0f2dac6febc7b7d5208c84285b39f18b1bd043aa8efb8f1e37250",
         "s1_eos": "ace06bd48049a9633d911405047bfae13b3e198da6cd8acd68cef618aeb10a28",
         "s0_period": "fe5158583cda206e673d2d0b75614506d4f2a47c60504979619a175968d95a79",
@@ -375,7 +591,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "453f97f6ad125aa964586c223548f0d9b80122625e41cbda2da04560624657fb",
+        "s1_eos": "059f027f79daa0a69a34572e5d476d93344c6b1b225ee7a4db1611b32719ad23",
+        "s0_period": "245c90fd66580cacd04ddd43e795e6fef55aabfe04b960ed84df2bb67ecff730",
+        "s1_period": "014cc919db3bc3463734b6c05e16ee1329d34776b9eb2817bbc70f954e372ef9"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 114,
+        "s1_eos": 130,
+        "s0_period": 114,
+        "s1_period": 130
+      }
     },
     {
       "id": "HumanEval/103",
@@ -383,7 +611,7 @@
       "domain_index": 19,
       "selection_rank": "14cb89bb17e2bbe27f2f4ae91dcb86866ff9ff855c1e5c701292aa6c434a4a51",
       "source_text_sha256": "82db1a09d55321f17fc5c9d69ef96b9ae24bdccd6f845d6c91e5969a6b0caf3d",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "abb34faf64df8c3560bdcf2f14b44cc6ab6beb9ffd9d00185725b16cdf0faac5",
         "s1_eos": "98b973f4e474bd22438d948bce0a087497bf870d1272badd1d5892e26b4d7442",
         "s0_period": "c9a00420e743b45663897718741ddc3a74badaaa8e39184fbd2b7ee49a167498",
@@ -393,7 +621,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "d28753ea3e63a6e5d4b049053bfc1a7969371706a4f741ecde0acd770d119713",
+        "s1_eos": "bf9573e454722dad989e5c3f5655383de83f379a9edf667223c0619dab5f08bb",
+        "s0_period": "7f5fa5cf5c0410473177935c384790c86952bcee4e674933e41b78518f0b4442",
+        "s1_period": "e4ef9407465b186595606ee6a21ee80e30a19eb850349eb5866de354a4598c79"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 184,
+        "s1_eos": 200,
+        "s0_period": 184,
+        "s1_period": 200
+      }
     },
     {
       "id": "HumanEval/25",
@@ -401,7 +641,7 @@
       "domain_index": 20,
       "selection_rank": "18fe53834c71c01cc9670bef92494b340e9cee5ead1927899fc7ea8a6120b031",
       "source_text_sha256": "12e9603b0cdbcbb862e3a790a25dbd1478ed55b331ce84c9bf79865337a5d17f",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "008b5386771e660cc5e9627282decda25c90e5a9b75393fbb551eadd081a2000",
         "s1_eos": "d659f8c478bc8a6ca5cc4ddd02e3979744a43a58dd1d70d741d9cf66b216edce",
         "s0_period": "b59fa6f1b0f5dcb10d292135a80414c958374014497f94c641cf9f1c6c1b65a1",
@@ -411,7 +651,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": true
+      "independent_replay": true,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "0f38b520f6db55822986dfa0083a4333689ab0e0129f2a2c0569ed35f7d5a7ab",
+        "s1_eos": "c4ba2171cdbfbba93c5700aaad2d462d207ed076d39529b28f1f9683d4715b4b",
+        "s0_period": "7c26216c950964d61060b26e5b8612ab583ec75cbf02ac8f37574dac19fb01fe",
+        "s1_period": "60616ac39697d747a883cb790733ef71eb0b911a599a6e9c2cbe8b5364168180"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 158,
+        "s1_eos": 174,
+        "s0_period": 158,
+        "s1_period": 174
+      }
     },
     {
       "id": "HumanEval/98",
@@ -419,7 +671,7 @@
       "domain_index": 21,
       "selection_rank": "1976fcfcc74e22e8001546540ff7297f08401a27b4868b8748bbcedd3cb60baa",
       "source_text_sha256": "11c1bca6656484296abc251387766d4ffd8aa560d1eb56b3949e4d45db10596e",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "8150b8ad01422cc6c29862faeb47d565642fdca635db45f5dadc69e95d1a945b",
         "s1_eos": "d4a28e727aad7ff1895cc30ec4847d76eebfc5116e7d709f1344de65bb4b77aa",
         "s0_period": "6d960563ef9915f42deb3647f839284d232650c00ec5227ce06a1e7092b08cf6",
@@ -429,7 +681,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "d566740280f47e3522734ac49ad6fdedbaa3d038d4dd3057a783546a2f008536",
+        "s1_eos": "3100c37eb2b4bdf85bc52fad4c3a7fe37bb5311c04662d554e0265e057179d3f",
+        "s0_period": "938273c38163315f1bb3320504d22f60ba2ff54184e9a071d55b82262e884778",
+        "s1_period": "087d2a64f5fd8f767c0502d2d1d5f0ed9716a63cfdaae7be67ba9907572ed30b"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 101,
+        "s1_eos": 117,
+        "s0_period": 101,
+        "s1_period": 117
+      }
     },
     {
       "id": "HumanEval/115",
@@ -437,7 +701,7 @@
       "domain_index": 22,
       "selection_rank": "19f11bc8d7cd0f17138960b42a559004aec5c51b92273382be6f4eda53b027a0",
       "source_text_sha256": "7fec019bed5056b0a2defe9c3716cd547b81bf4472b02247eee7aed7cef20d82",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "6c9f7961965fbb26230a83398ed310ea57fb82187d6b2e30a4d17c35754baee2",
         "s1_eos": "bd67206d07f8120b815b449476b17850d7aff6c6f4832f2963d47090a57c2ecb",
         "s0_period": "2b8a739358f2f0f729be134ac2aca2db22e60f0ac14d77eb14a7dbf7fdc53011",
@@ -447,7 +711,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "a73dbc028008ef9bd33f7ae2cc9f609453a79bc0ce769140c814fce836577879",
+        "s1_eos": "933ccbf87cd635f211802cc687d763167248a049785c47d97cef2d2d5562957f",
+        "s0_period": "213ecc22d308711a8f858eb070250edd045a30e1cb0a1811dd3479017237cb39",
+        "s1_period": "5d8c1bf1a400d6b0f8ba1f0a186195108cf1b31b87ca23553d41267a2ef32648"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 377,
+        "s1_eos": 393,
+        "s0_period": 377,
+        "s1_period": 393
+      }
     },
     {
       "id": "HumanEval/10",
@@ -455,7 +731,7 @@
       "domain_index": 23,
       "selection_rank": "1f38e7c9bd528dba6fb5f380a993ced57091a5eee4a68cb07cafe93b5e60af52",
       "source_text_sha256": "ba94307a7a0a8d7c490e889c1daf9f07dbc81f3a39d598138c181c212940e49a",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "364bf44139c0462ca4bcc49e63ebad500338a9ad08d3e9cee8c02177670fe1ff",
         "s1_eos": "fdfa1d03266a6170a3db04066859df942073f5f826ac2537c2802ae9c9eb26f7",
         "s0_period": "66d40517ba20b9a028d4cf38773c7b8554c7d0c53e9d9d6c5fbb2eb363cec6ae",
@@ -465,7 +741,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "86703841a2adbccbdf78b087131021deae6cf3b91daffbd21576995873ec2c83",
+        "s1_eos": "80c810e58f93fc03ad408ab4de28d9358f86fc769695ae463a745bdcbf54b75f",
+        "s0_period": "adf64a1920bc39cad3bacbced068251b9bce28bfae498e509a412a10b76c86d0",
+        "s1_period": "65eb9c21f58d966f68958e9caa251ddbb7b21def1e56c543fb3e654db68bea94"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 197,
+        "s1_eos": 213,
+        "s0_period": 197,
+        "s1_period": 213
+      }
     },
     {
       "id": "HumanEval/141",
@@ -473,7 +761,7 @@
       "domain_index": 24,
       "selection_rank": "2088e9549375dcbefdfc7beb3bac56fbbd0d1d18dc09962421d2e3caa33af6e7",
       "source_text_sha256": "83dce9f11beb7fa7a38f51846361581bce1775c55debdc2d8578eee8e7fd2c13",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "a028dc5a7a3590901ced6cc20b746ef23da96688cd22cc83896d96c3b95a87da",
         "s1_eos": "cce0c490343e8eb7cf309e804bed4e572faf1d88efd37e65747a10e4ae2ca3b7",
         "s0_period": "f5b0ae39329c55899a783d0a7bebed8a34fb3eb508b6e09cb82bca0b28e9c7fa",
@@ -487,7 +775,19 @@
         "T2",
         "T3"
       ],
-      "independent_replay": true
+      "independent_replay": true,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "6b95f296e3f0a3207be85f518a2fb7a739cf9672af279f3cc94de29a9ca35976",
+        "s1_eos": "947e4149013f250c97d299628a11541d04caf5c0c4868a2ccbc352887099fbf3",
+        "s0_period": "2830ac9c67193f2c21e9d70a731b4e4b2893ed4fb67bb4090ffb2214cc1941b0",
+        "s1_period": "ce203361e76fd107dcd10cc1cc951b5f0da04798f0e0c2869535991bc4d5d7c9"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 260,
+        "s1_eos": 276,
+        "s0_period": 260,
+        "s1_period": 276
+      }
     },
     {
       "id": "HumanEval/91",
@@ -495,7 +795,7 @@
       "domain_index": 25,
       "selection_rank": "224e1881a15e5af9898c4481d2d4d42194a182d6b2359d760c5378389d0a0cf6",
       "source_text_sha256": "e0ad45711e34cf692a9bb9a0940d1514add9d88e46b98a78a2649ec161f53d65",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "8718d95258b5699021eea917f8e988072cd3693ede85617b33641d60fae7100f",
         "s1_eos": "c7888672ceb546468f7d3b13248d060ace7eb3f52b0a2795096a83346601d9c1",
         "s0_period": "60134f0f46b5ae9f5f7e1e133f78ab7723f65b7395c48c62f258dacdb279e0d2",
@@ -505,7 +805,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "087a527258799cc87565557c70b00241f04200eb80121bd487c00b3325fd04bc",
+        "s1_eos": "6d709828c5cff5a1bc5d56f48b9149b883c5c2c65b3b99fc1d772492b6faa395",
+        "s0_period": "9bf4d34f8cd5837eafacd6d04d5e4b096426132c13fe352bce625bfaed65c7a5",
+        "s1_period": "79c50272c0031fbc11182b6eaaeb64175e8a3a99f719ab1dfcb6bab2abd80213"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 142,
+        "s1_eos": 158,
+        "s0_period": 142,
+        "s1_period": 158
+      }
     },
     {
       "id": "HumanEval/122",
@@ -513,7 +825,7 @@
       "domain_index": 26,
       "selection_rank": "22bd978cdd54b34eff1d494b071983b628871d89af06188150a80f16c492bcd7",
       "source_text_sha256": "d725bd96292ea57f542b6762d55dfacac2ec7d08907941ccca81aaa347ac053e",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "3139d57c16d5dec6e7860dbbab99d451f8c53195ad5f54bd55868c997fb2f8d7",
         "s1_eos": "50ce61142aa5cab9f7372f78a004c24518b669940d8cc9fc94fdb726eff92dba",
         "s0_period": "fba3772d1945be22f53c30a41d32aaef4958f96a555a22991d964d8f66d175fc",
@@ -523,7 +835,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "6e978409707648d68c1ec8673fc894641baf0001c5daeb88e738567165e324e3",
+        "s1_eos": "1bef3fc8822ea1fcbb5b10356df3726406e24be935b2c35c8f997b6b3a51908f",
+        "s0_period": "cdacc4931dfe88a9f8451ac93bed8453c84e773d8ae7da0f1ddf724ac5bf76cf",
+        "s1_period": "4466d904daeed9812cd02e5bc7e141ce1b018de1478132cc69d335717f928176"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 170,
+        "s1_eos": 186,
+        "s0_period": 170,
+        "s1_period": 186
+      }
     },
     {
       "id": "HumanEval/75",
@@ -531,7 +855,7 @@
       "domain_index": 27,
       "selection_rank": "22cf87a8ef93326fdcc2f72d8ac20f7e24a1f76d8d507b22fa7ce414bbd61077",
       "source_text_sha256": "453da210ee2432b4f676136ec260c5d3e4208dc1e7e3d7a5b1d828e626a41eb2",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "13284422826c13b4a05bc509ef53724cb0f2dc7d8914c160fa63683cf8307d3e",
         "s1_eos": "d274f2b89aabdb9f2285d1e2233ce8d00c69638581eb73b21a88a8ec28b3d349",
         "s0_period": "5b73da7a5a302a8566fd704cf0af807bc31602a622f6d6eea086320c92052c64",
@@ -541,7 +865,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "96b0f17f51329f8f6b91188f9e2e3f3ece2d439b77b87e350b2a25b2b098e523",
+        "s1_eos": "93891b8ee5104676868cb6a27a9f5271ec864f1ab2da5d015cf67764c13538ad",
+        "s0_period": "6f2395599ea69561eabe49bf4cbb1ae77e6fd51629da632aa463db5639d06dd6",
+        "s1_period": "9cfc7246ecd0b71edb946084de0c0c7708a87cef1f21a80ff03b21729e179b5d"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 111,
+        "s1_eos": 127,
+        "s0_period": 111,
+        "s1_period": 127
+      }
     },
     {
       "id": "HumanEval/134",
@@ -549,7 +885,7 @@
       "domain_index": 28,
       "selection_rank": "22eea753219750e26ceda942caf857620485120e116dc434412c40471bcf80d3",
       "source_text_sha256": "cd08bd2eab53c655bee6f670158d1f3ccd198e2500bfed1a0fa3b9dfbb28d4f0",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "116e6cab53680405e0e482419ca81140023c6313316f8c266251b7f76f9782b4",
         "s1_eos": "acdcd2f18ea59c8d961700d2f6e4c877bcfce7a8e896911e3ddc66721f3a3224",
         "s0_period": "c21c2757d50db4f53b650b06b6db166236bce49dee2b83cfdc21cad160a40eb5",
@@ -559,7 +895,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": true
+      "independent_replay": true,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "37f15416dca557362a40747feab9b67e398594956d96f65b4c450fc286e07d9d",
+        "s1_eos": "b57e0fa3d3e10bc2ebb421dbb384fa5bea4451067a1fc983d79f6be61472f35a",
+        "s0_period": "7210c29be547ae840811d59931029cc6f00c1e4bc567260bc4d6a9c44bfbca35",
+        "s1_period": "824dffd7a1aff03646950c6d0a05aa5e81b6b9bf36782b99ba7178ed687223de"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 199,
+        "s1_eos": 215,
+        "s0_period": 199,
+        "s1_period": 215
+      }
     },
     {
       "id": "HumanEval/142",
@@ -567,7 +915,7 @@
       "domain_index": 29,
       "selection_rank": "2558f93c2d7e0b026c8427e12ffbbe04dcb9ba6aa37d3f5baf51f6aa67caede8",
       "source_text_sha256": "9a63a21d2c849c05ab21dc8cb7c448a5488a58d26ecd64c3cab438e7d7c759d2",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "ee9ddf7e4a819e4799d2c6d28061ccbd377005f8351d38d8181452d74ae96b7e",
         "s1_eos": "62d4effe5e30539c035f77b76838a62bb6f3ddc6a4c53de09b0667cba9810408",
         "s0_period": "500c8c34bb6fd0b5d77308bf8980581651e00190e4f538f9439be129c167bc65",
@@ -577,7 +925,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "da5dfc5e1bea096731bcce1b3752c1ad81c5ec52045a42246db9b2c7ede51e7f",
+        "s1_eos": "b24667fcbfbe1cdf49797767d6f28e6c9f8d4e80a40093710b91cb4a3d5a1e1d",
+        "s0_period": "9e985bcc07892d01fbd73e5be3c8a341785660c8194523979cdd82be1b134a25",
+        "s1_period": "773e20b33c383d986d5f2021aba0c917d145a64e9fe14b32f7275ba8e942dc73"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 202,
+        "s1_eos": 218,
+        "s0_period": 202,
+        "s1_period": 218
+      }
     },
     {
       "id": "HumanEval/149",
@@ -585,7 +945,7 @@
       "domain_index": 30,
       "selection_rank": "26c65bd4dabdf18fe88f4b40d05b0830d3a46b2b6628cb210f767980c49ba381",
       "source_text_sha256": "29bdd295d2312cd6be141f31c1bda08d9165274526c3d0ab5e5ac7b3050ada40",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "d08549c7f49b37e5f0405e32152a60ba8cfa0331745b799504e54cbfb04094c6",
         "s1_eos": "c5aedd3defba8d749550275c4b1f4815b4329e258f9bd042049c8099e4cd48e1",
         "s0_period": "3f2abdf1d60c4502882418535d6dfe59b88627877f6c3f5abece3740bb06b075",
@@ -595,7 +955,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "cac776a59dab56be04145bf3c6ed92afb4fcdbf5fecf2d03d5e63cdc3ec71ac5",
+        "s1_eos": "b9963a1a1d24a173956b042b86e1a0d5a34514c2050d547959315e573c8f3c59",
+        "s0_period": "0d8b00b6b3f3af66af152197d62c1202d23e2864ac5704ef6212d68d0b2ca457",
+        "s1_period": "189560513d5522eb7cb1b8e0f1f8773bc24e6a6df5cc7ce08442daac3db0d853"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 225,
+        "s1_eos": 241,
+        "s0_period": 225,
+        "s1_period": 241
+      }
     },
     {
       "id": "HumanEval/102",
@@ -603,7 +975,7 @@
       "domain_index": 31,
       "selection_rank": "285d2858f6c6758e66af36954d25c5cf8a846e1f7f2cbe1b11c5ecae0af80263",
       "source_text_sha256": "15652ca300e14ab83ca395d57a5b770c1d13e4aa2a900b10d6aabc6a77d05223",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "10f426b1abd51322bf70819dafc44af8ca8283f33a1ac3cf4cebb1f922917180",
         "s1_eos": "c12a2e86abf45c7e729f344336629cfc4bdee4655f99b74a997a59f76260fabb",
         "s0_period": "f151d974953a5013bb557151a46d8758df5ff22051a046abc3e8e3692967fcf5",
@@ -613,7 +985,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "fe4dccc09d5da99258a7f7d430fcf171edeba084e5538f9c3b9cd1c825994eee",
+        "s1_eos": "97bdf59127dc02e3474f82b423789573a1c4e3a1bd62ba9f4d699ba5940d7515",
+        "s0_period": "de08049376d52aa9687e92c49bc63e633b7ba262b2667ee025baaaf2fe00b76b",
+        "s1_period": "a89e5e0cf1dfe8bd00cce6150395d08bd6c69d16a4e9d80a23752b68c3c93ce2"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 129,
+        "s1_eos": 145,
+        "s0_period": 129,
+        "s1_period": 145
+      }
     },
     {
       "id": "gsm8k/test/1069",
@@ -621,7 +1005,7 @@
       "domain_index": 0,
       "selection_rank": "000946b459ce33a645f403b9d781a7aefd81f5568412149f4588381fed55b1d7",
       "source_text_sha256": "0cc2ca2bdd6ee8d664eb1197e8020bac71c25ba0ce52d813fc4adbf08df22378",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "f18b1ab81945738da2e32e8b125a022710ce45c6143b45d8ca13df6469d34ea1",
         "s1_eos": "09336f425a886a0fbe460639523aac22cfaa1cde4e4bb090246da3a338cf6b42",
         "s0_period": "66afcd11149d1b34a62305b2278b09dba96ce7f47c22b0bbdc7f7b17fd3f58ba",
@@ -635,7 +1019,19 @@
         "T2",
         "T3"
       ],
-      "independent_replay": true
+      "independent_replay": true,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "af8148f2dd065587b6d5a13e8fe115de24ccbdaa6dacd40254d522b17c1ff83b",
+        "s1_eos": "6fc9f186b31f6926a443a0d8218e5e92ff09af381a872054c954792ca2d2204f",
+        "s0_period": "c9871468f54fb12742eb484332b45383b61d6ba4fc0250e2f2d929165251b35b",
+        "s1_period": "c2f1b1ae4a81b97e603806b23729d92b118bc3de70c647ae0d91c62f6b6912cc"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 131,
+        "s1_eos": 147,
+        "s0_period": 131,
+        "s1_period": 147
+      }
     },
     {
       "id": "gsm8k/test/1228",
@@ -643,7 +1039,7 @@
       "domain_index": 1,
       "selection_rank": "002201d4cbc0b85d338597dcb68c3ffd4d00ef12b7b44e352c5bc1911d6fa984",
       "source_text_sha256": "3931b6363f3a060ca7cb0774662127e64007e9f34ce209edddca77425e20a479",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "83658d07cb0988b7cbd74a81e597117cf0e09235294b78873b7cdc8b7da6805b",
         "s1_eos": "73497c3325f69f2666625cce2bbc77f5f0197e3287e256bb44aeb6f6cff83559",
         "s0_period": "cf5d4d0156a790e702203557d710831ac6fe7f2e709556f3e54c24882c616b16",
@@ -653,7 +1049,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "32ada50df0fccf416d8c91e21dbb4bdd2246fcd7afaa04a69f1f38fc50f8ca5c",
+        "s1_eos": "f30e793e92ed3c09cac2e94c1d37a636ca60e1ff8d4e540bd4bb32914bc9f728",
+        "s0_period": "945934580628dcd1edf2a85b5c83c6afb72ffde9ddec26f5568f6780c953ee22",
+        "s1_period": "a3debe06e713b24eeba50430c4ab26a96682361c0ad76de71fc9a9e5c319efda"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 59,
+        "s1_eos": 75,
+        "s0_period": 59,
+        "s1_period": 75
+      }
     },
     {
       "id": "gsm8k/test/0144",
@@ -661,7 +1069,7 @@
       "domain_index": 2,
       "selection_rank": "004a245538bdc42cc175a178c73dfaaaebc9713e3215ffcdfb9400fb63b3a941",
       "source_text_sha256": "8f2ecd574d8c8738ec87b6ba3a3af24f9cbf35d832733c98e65546f7ee59725d",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "6024c63249b3dc8eb52d0d90542991b0c4ad74a229d7911c1c177d738fb7ad51",
         "s1_eos": "87db024f771ce0454066cff4046274c265284f2d4d804dd0928c9e0234002e0c",
         "s0_period": "be880ce76c36b376deaeff9209ad0689563ad54f9e9a072d93199d1482d24d5f",
@@ -671,7 +1079,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "d8dc51585cedab0a1ad0851d7e762b43f4e0c384234e27717205b618bdbcd926",
+        "s1_eos": "e9be7845cdbf1b842381628cfb7fc89a2856e64d6ad742734daccb7870279f73",
+        "s0_period": "85b762195d6e87a0e483912ff46ed28ae1e6703374a433ef6e8406fe5a258399",
+        "s1_period": "8a549e4eefb67f9c7df04d2d81824500fadbeb873948fda10055fbc3bb0ac287"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 155,
+        "s1_eos": 171,
+        "s0_period": 155,
+        "s1_period": 171
+      }
     },
     {
       "id": "gsm8k/test/1251",
@@ -679,7 +1099,7 @@
       "domain_index": 3,
       "selection_rank": "0056e66a635febc5b2ace25221ed8fe25366682898fc2d4d0132b30812f59e30",
       "source_text_sha256": "a45936495f064c16cf6621fe21bf0d84f54f5850bf6bfe19ced45b30c591aa36",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "67a88758cbdf61af3b2742efb3bfc7f22ab6fb0851e8ee801cadb0aefba3a504",
         "s1_eos": "2fa687b5c4a1176cad1b14b25ea7619bc3aa21983182fb774527fe69d3489609",
         "s0_period": "9f20020cdaf7244aeff4b240e15cf332e9a4cdced0dc35cff49a22e927b61b11",
@@ -689,7 +1109,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "49fe40432f2d059dd188bd35dc10f373d43b74c3d1e0afcb89c1ef642f8d5b6c",
+        "s1_eos": "9826fc7ee5c2b9677c860ff687740351402c53395073d397a387bb812035d3ed",
+        "s0_period": "44c836c323e7e7a07a5153325738d347e28b910234dfb1a8883184546ecadd9f",
+        "s1_period": "ff4b886b7a2e0289202dd757d2754cc337b6577268f81cdc2ac0b5db5f2edf9f"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 99,
+        "s1_eos": 115,
+        "s0_period": 99,
+        "s1_period": 115
+      }
     },
     {
       "id": "gsm8k/test/0676",
@@ -697,7 +1129,7 @@
       "domain_index": 4,
       "selection_rank": "007dc3953514b93637a47cf96da05c0eb643a6d67337f9513efc328c3a50de12",
       "source_text_sha256": "ce589ecfd3ab0f3d1d03835a292fb5029f9d91cf434342da860f0fd0502e8323",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "c890b320355dc2d0a1a578821e4ae36a57cb2653d4cfc03c6d1d20bbe9a0f391",
         "s1_eos": "f8cfd874be86837cb6f805a22e5d04ecfd596167065b0ad4890e9513b3c4e422",
         "s0_period": "a30d5afc1522ffa514ddf5b5bbd714da69889724aa36f18b0129229a036db715",
@@ -707,7 +1139,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": true
+      "independent_replay": true,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "bcd935d1e1be918dee1be746b3f4a0f4b7a75925a09d5355d005a0087fb68533",
+        "s1_eos": "2d38e3d859165414458c2348215fc3ae0e4f34c08d6ac09fb111ec80a4e4a0c3",
+        "s0_period": "8fe4d3e06e2505f356910ed51c14db8e427feeda95109fcd54d30375fa5521f0",
+        "s1_period": "856b10eb1aae2587c4809f25599c83e8d61298f426be08c52597629fd85776ea"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 86,
+        "s1_eos": 102,
+        "s0_period": 86,
+        "s1_period": 102
+      }
     },
     {
       "id": "gsm8k/test/0126",
@@ -715,7 +1159,7 @@
       "domain_index": 5,
       "selection_rank": "00b20ae940ac731b073dbf7adae91f69acdb81ecf4d92a0727f9edbdbe14d634",
       "source_text_sha256": "d0798145442485f3c0cfcdfd90a7ce1c5d2eb7496d997bc8c3423c1b8e99e49e",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "42c33b13cc1155eda2bcf4eac8e42640a59b1270ec43212ad0fd878357c0b8de",
         "s1_eos": "6c9296e0ce46e6645bfb47f42ba41e054aed769507435a4fc868de56efbb40ea",
         "s0_period": "561f1d96511bc71e1250dc3478f6dd420fbeb6a0eeb4722ff903a438086110f3",
@@ -725,7 +1169,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "b03025807823dc5b8c0c3ee7b2a3915ae70917ca9e9e195fee2ccb2019167b2e",
+        "s1_eos": "2a3b4625f10e8490b3891f118bf28b391fef966fe19c5d10267c31dfe8278a32",
+        "s0_period": "5e0d05046ef1af294eeebffd3586159b873f2fafec5eb7121b80d235ffea72f4",
+        "s1_period": "fd094aa51a52897ae5bad500b09c5237c75837e22b08bfd1aac96749497f5751"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 65,
+        "s1_eos": 81,
+        "s0_period": 65,
+        "s1_period": 81
+      }
     },
     {
       "id": "gsm8k/test/0438",
@@ -733,7 +1189,7 @@
       "domain_index": 6,
       "selection_rank": "017a97d03b63645963eea1c1f6a69b071b41c2be4d43e3fffd4f1dffa6986cdc",
       "source_text_sha256": "0246c431c39aa3351713edd9f897904b632abc5414727b7e0bb7ffb51e0804a1",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "3736af9c3456583b2249d50aa45b27bedc2a90f143e77201d73682f8108aec73",
         "s1_eos": "ed42a4cd317988656e1ed154fda077a6cdbb369c96cf8aae4ba37b49144d876d",
         "s0_period": "e882c307ae0e4221c05b08099d3e0fb2943fc6416b2ae513682bca73d8795987",
@@ -743,7 +1199,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "791697cdd4681bf6eebdfdc9797985c92cf55dd750e4913520cbe7b92872157b",
+        "s1_eos": "101711bb86ba1d58641a8874cead57859020efaa9d1d7e9bd1dfa76a5fb81954",
+        "s0_period": "2b485b7365e70548317ce459d748ea4e2dd7df2619c9b6bf9402210d891689ef",
+        "s1_period": "1b259eda6bb486ee8cc19f46d8d528b0f71f0a7e309f9cd1c1f8755cfd453547"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 107,
+        "s1_eos": 123,
+        "s0_period": 107,
+        "s1_period": 123
+      }
     },
     {
       "id": "gsm8k/test/1299",
@@ -751,7 +1219,7 @@
       "domain_index": 7,
       "selection_rank": "01905ee47b39eb58804378d2e1e469bfb676f2f1524864076667215f0f12815e",
       "source_text_sha256": "d4350e7f863b05ee6fc0dc0e92fe04815e183172553fc1674fbef33febb33971",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "7d7082e770e9856f30414c0c855592e7fcdfa6d2616e3f1e78c013b9edc98d5a",
         "s1_eos": "0907bc1bc4fb9702bfafae016dcc58e441b02cc0b0861991b37fc4820b085b3f",
         "s0_period": "2a2e1d480678611c601a5c98bf916de7d95027baa63371a4a2c12f563887a3f6",
@@ -761,7 +1229,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "76a3baf126c9a7b6f612dd6cab49db4481d5cb68c0888117e1bc4411f2d81adc",
+        "s1_eos": "8df6933c900688235dab89382dd6ac97518f2cad1a64afc39338253f38866d3d",
+        "s0_period": "0f5ad04460a04c08f5870b1ad6ccfbfbee7950aac5e1e82f4ec412337a0c89f3",
+        "s1_period": "26a20c55aff1adc16eea128ead90f266d0b9eebc04294745d705162037f65abd"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 83,
+        "s1_eos": 99,
+        "s0_period": 83,
+        "s1_period": 99
+      }
     },
     {
       "id": "gsm8k/test/0546",
@@ -769,7 +1249,7 @@
       "domain_index": 8,
       "selection_rank": "01ebd6fb979d45e8755a234bffd810bc5ec36423c0fbd8bf344a799e5e0993a6",
       "source_text_sha256": "8619c48853d9610e152a7525a70d157c33e2f3ec1f9bcc8b41f927324527d5f2",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "f541a80cc280c6895b3b4b2f8ec5e58f75cbaebc4af63ec907461d352a5cc022",
         "s1_eos": "84ddace95218cd7fc6cea61ca3d9ca463bb779212ae5668cdd40fb503dc9dd8c",
         "s0_period": "82b528af177d489acf469e86715f99f7c9891b15ccea8ff4ed0b360a4365ce47",
@@ -783,7 +1263,19 @@
         "T2",
         "T3"
       ],
-      "independent_replay": true
+      "independent_replay": true,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "1d48e6c07ba98ecc025652caf3ec955f335adc6924a64040c371dac92e8ef239",
+        "s1_eos": "e3b3469c7454a5423532ced0fd0006749e09fff43d0eae49944b4ba7106b6d4b",
+        "s0_period": "7005e757ffd6257eeb6b1ae0fe0f3fae9e81371cf31bc5dfc2b96f709c620b0e",
+        "s1_period": "9d75edb70e038da357e44158e5306f5748bc88e7fc3ebf669989a0181027551c"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 75,
+        "s1_eos": 91,
+        "s0_period": 75,
+        "s1_period": 91
+      }
     },
     {
       "id": "gsm8k/test/0537",
@@ -791,7 +1283,7 @@
       "domain_index": 9,
       "selection_rank": "01ed2a6eaa7e8c6439db165853d4bcf48477213319beeb260fa08b7f3d7df971",
       "source_text_sha256": "a9af7c44056527232865dbdf9952a307e8c3f2db4685e5abe30d0281646780cd",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "71a94bf2c87b0cd8f9a7591940a09f6625c2ff5495f6489361be29e26a9f56d4",
         "s1_eos": "ef240167f5b53338e4abd5080e4f0643cc05db10bbfb6d0efea0612b93e48e2c",
         "s0_period": "582ce43df4e935e0f6144145969aa9ad1c86d638f2c12ffa74f9d3e488fe17a4",
@@ -801,7 +1293,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "4b4619bc9335cf84afb3b1f39e7aebc47aaf346f7e9443b4b2a377f516882fea",
+        "s1_eos": "19a43d486489b2d5be61f63ff61e6f8475daac5b9d639beae861acb4508f7e31",
+        "s0_period": "20f02d161bade007b210de31ca5c6f490a9bf7ae0c2c8b85d57e419798643976",
+        "s1_period": "3a9f7586b74609b9384367b3896c555a3f14d0582fd0ebe98acb6a1bc174d993"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 89,
+        "s1_eos": 105,
+        "s0_period": 89,
+        "s1_period": 105
+      }
     },
     {
       "id": "gsm8k/test/0226",
@@ -809,7 +1313,7 @@
       "domain_index": 10,
       "selection_rank": "01ef79122976f164519533009f7bbb5f72fd91d9c90f6c5a4df80ed3091d303a",
       "source_text_sha256": "d58e5838fc7750bc87cf98d3888c5cb7bac568a0c7969d1466ce5fd6acb956fc",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "d5867f77ff3258595f13a65b243359568e11b130297912ff597d2ea6d5468144",
         "s1_eos": "3c3083464ffcf2e6c3c8855a3f50db7c8cee4db7605c5948b52794fdce603583",
         "s0_period": "de593445d8d3ad3162890b148a5f2479c034d8a276b2fd8e2f62c1ec6e010ccc",
@@ -819,7 +1323,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "69d76c4ce354eed6280fa1384f54c71e16604e0b13a18645ba73e16b3cd25441",
+        "s1_eos": "234d2923d7c0b083fb33b4f8807e18ad86c06fead7249f7237c8dca8f450e887",
+        "s0_period": "80d014f7b99cea5b66cbeacd103e90387467decad7a1daa28e6365f236e6a671",
+        "s1_period": "e5ec32dbf15ed5107599c8fdcde9c25cf00aaf3ab58a5fcf4f677f18d2d68f2f"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 93,
+        "s1_eos": 109,
+        "s0_period": 93,
+        "s1_period": 109
+      }
     },
     {
       "id": "gsm8k/test/1128",
@@ -827,7 +1343,7 @@
       "domain_index": 11,
       "selection_rank": "020803c399cd482ba6ad3ca246e7c695d62e95673fd612481a8f9ac21f646e54",
       "source_text_sha256": "9105ce5963e380fed4744960fecf97a99f44de151f6b4d5fc2c48e8817f3225d",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "52727d484c42c7e94ebd9af0a93a6e8c915fd12397ce65dec84ceb9162dc9a90",
         "s1_eos": "264621d37e45d1fd34a1626589aba9c43ccafb4706b8ff74a80e33f24587c94d",
         "s0_period": "e69f030f2d8503473730ba3a9f40bd7666b1a577f5945854c5b3df5f2d6e2ae1",
@@ -837,7 +1353,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "4a809c71cf417d0d0d0e0ae53f7a74f55fd5dcd2f2505a0b825fc9c902badc58",
+        "s1_eos": "91dce23ab426b59b7a7a176c47f12f8c582db9dfc1e873e37df1835adb59f7fd",
+        "s0_period": "69e16e16f7de2aa9e6e978b54d858b6114fa15bd0eb0b3b0fa96765ea1dd0407",
+        "s1_period": "6598b377c09f90a8dc9e1771d1472c85c7359032287ce8b10869a74162b6f8c6"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 54,
+        "s1_eos": 70,
+        "s0_period": 54,
+        "s1_period": 70
+      }
     },
     {
       "id": "gsm8k/test/0760",
@@ -845,7 +1373,7 @@
       "domain_index": 12,
       "selection_rank": "0208e9afa6cd76d86a6e08fecb0736003ef967fa0a434352c3c4053fdd11b5a2",
       "source_text_sha256": "65a55bc0c16200440b69c4cef6334f0a33798b1fd5a1c079300911ebccb75a06",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "8ce20b40bdb99e4a074e2aa49d6387fed6a87cbd3a08f9b9358cba3d5309a6d4",
         "s1_eos": "ae3851beb4032e4f9976924634edd56ded0ff6e8410da3bf6b3675316556d7a2",
         "s0_period": "4495e2738d8ec84efe9cd08ad4d7cc7c74ab5ce3ce1a4a48e926d24a270b76f4",
@@ -855,7 +1383,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": true
+      "independent_replay": true,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "1029105509171d0da7873f207386bc028bbfc96975d90ef2d9ad497c7df5fcc9",
+        "s1_eos": "a8162315985546595aa2c526b2f3dca76b2843f6c6fbe6e3c91379d6a9af4fe3",
+        "s0_period": "dbfee38d37940e873552bbfad6f624e14c4b87fc8d1a0925825dca4329410086",
+        "s1_period": "657517f295b2085f2443ad0a71f8b39eb49782cb686610283c6149b87a68d2bb"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 88,
+        "s1_eos": 104,
+        "s0_period": 88,
+        "s1_period": 104
+      }
     },
     {
       "id": "gsm8k/test/1173",
@@ -863,7 +1403,7 @@
       "domain_index": 13,
       "selection_rank": "02a7c343f3c4a74787465d7e08787db473bdd1ee6c296341979585eb5da0d3d8",
       "source_text_sha256": "6206bc51a78315ffc176309157e0bdb07d5eb50510d21e8555c6370c7fce9df9",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "7a07020f6f73b0aab44a10ae7a77d4687445fd8e79aa4c8544633122ceed1bd4",
         "s1_eos": "bf48634fda477a400a0fbdb7fe3737b17a95dbb86290292ea7b6a910cde07cc9",
         "s0_period": "4b6f1cc014d4418ea28415d5348e53b3abe6a30cf6560ee31cacba2a1178ae5c",
@@ -873,7 +1413,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "e9028c59c33248d532d0a8b37ff5806c1b5fd5f86294e9cb2799dcbc236ec496",
+        "s1_eos": "d170f72b8c1643f826669cbbe0dde7c9bf7cdb1f62e4f4693b1ac84d6c38eb5b",
+        "s0_period": "c51b808e30ce1e4cb56b62a844329e6b3aa3af59883639ae09fd495a3db2d09c",
+        "s1_period": "57ad400444b27cfc237bd0b7478e79cc4a079d4a37e16a07d82901d6d3662909"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 84,
+        "s1_eos": 100,
+        "s0_period": 84,
+        "s1_period": 100
+      }
     },
     {
       "id": "gsm8k/test/0452",
@@ -881,7 +1433,7 @@
       "domain_index": 14,
       "selection_rank": "02d8131120fedb69911cd70aa26c56591fc5bcdba6fd3157fd571c410d039988",
       "source_text_sha256": "5102790b75edc5b1a8d08709e3784fc762dabba766ae03b14828bd18bc7cdbf2",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "5840d636471247bae3184bd15b5bc89a0994f07009438bbe41a6051de077b1fe",
         "s1_eos": "83d9af33a6fc56b45ad62054d36189919424c11de77c771b50d96014b2eac256",
         "s0_period": "e14cdacb293045d67d4ae47e9a16ac69094e6fe77bb8cc045d2a5297059b0fe6",
@@ -891,7 +1443,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "e1c56d98d3242283db4186973b4c176b452821770a252a34703358479486b5a6",
+        "s1_eos": "9b931d703aed7643948def1234ef3492241b7dc5f650cb08aa5b448892ab6371",
+        "s0_period": "55a92b3e87e39bf846d92b152b08aff5ba766ebcade6417f6ae328e1dfa6984e",
+        "s1_period": "7bd7e4fcba2c83e10de453305957a304ba3d1f0e63ea355fcb9dee7868994d50"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 67,
+        "s1_eos": 83,
+        "s0_period": 67,
+        "s1_period": 83
+      }
     },
     {
       "id": "gsm8k/test/0357",
@@ -899,7 +1463,7 @@
       "domain_index": 15,
       "selection_rank": "02f701d64bfd4ed535275bd8010260c8884dd2e0ed21a5f102084e82c286f84f",
       "source_text_sha256": "dc1b264fc4aefafbed621c9e844315a6e512d5d91ccbdc591d21512a2ab9e855",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "304784cf8f1dbab4fac0f830bc409aee7b73545a306949244474cebbacf45f02",
         "s1_eos": "15b1516b88dff7216e2ddc793dfa931c4d97b3ac97f6737c1f7f870050107e35",
         "s0_period": "4f770a111c25c8cd2355a7546e19413e9e82ea62fa00c66b9ca5a50001b54033",
@@ -909,7 +1473,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "80150382a8ca8da20d809ee707e6a4cf983c7cf6fa84c9f380c2cdbfc3fc4c11",
+        "s1_eos": "24c427bb15bcf70e24b2b78578269d57e5b4b1bad2c35617ae0aa56e3f79e708",
+        "s0_period": "86c986a820b0f689a84a6a8122b49949b4e806c65e428e3c48b4e8585ce6f56b",
+        "s1_period": "367ad4073e1747d8342672ac78cf312d1b26e63f2b81c93824ebec026a804abd"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 111,
+        "s1_eos": 127,
+        "s0_period": 111,
+        "s1_period": 127
+      }
     },
     {
       "id": "gsm8k/test/1050",
@@ -917,7 +1493,7 @@
       "domain_index": 16,
       "selection_rank": "032013ab41bff5a0bd0eff093a92ef002a0dec6e348ebb5d723e58176574151a",
       "source_text_sha256": "8af254886db4666b82ef6475cef3644fe4ed391d4eae588c13b19173d19f75ad",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "8ab8b472fc249ccaeeac8319981b0b0d3b80f0ec92f530f3730a3f1287b791ed",
         "s1_eos": "8db9a2e97eed8c7b85434cd86d557e94133a293a7e06a189095c8e2c79bb78ce",
         "s0_period": "1a8b7a31afee52ca22a1cb1d9d0dcbfd47feb024f158a300072c17d13f11e51a",
@@ -931,7 +1507,19 @@
         "T2",
         "T3"
       ],
-      "independent_replay": true
+      "independent_replay": true,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "0e98dc0c8145a66a67515d1b4f370e93524d62044e2d5fa7ce6e96a517e36255",
+        "s1_eos": "6ad773a70875c1f7464f27152ed3995223a8a7b6f5b1361fe979deece32af041",
+        "s0_period": "79ae0cf2887a0b4decd82a401d0ab0b7193b59685a8b2c1d931f9b68a3e70279",
+        "s1_period": "89c88d47315b40ac013df9dfdb518b2c9ab8e55c4d917ee3991d4676e0952ba4"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 70,
+        "s1_eos": 86,
+        "s0_period": 70,
+        "s1_period": 86
+      }
     },
     {
       "id": "gsm8k/test/0951",
@@ -939,7 +1527,7 @@
       "domain_index": 17,
       "selection_rank": "032d853068a127a2d89b7aea49ace29b4c161f55c9dc4beec570b38e2f173406",
       "source_text_sha256": "8fd6525f5b25a51226ed5c53e8d6fa871061e7d766d51d66cddc37eade3888ef",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "e6c89bf1e8fd4d01d1d2ca7fda4018121c8ee15955fa233bc19cb230a9a96ddc",
         "s1_eos": "8962f074c0900700d95b84de226a16c54fca06fdcd0db2682cdd4bf46657e8a3",
         "s0_period": "19581e485e193a2b090cf037781ea34221a42981b0bf113b8f2517bd51aa2a1a",
@@ -949,7 +1537,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "df77a9be24905e684b8a7d1685e5815a926774cab14a7c99bbcee868af90c385",
+        "s1_eos": "ab2543e3922c7fdaf1239632ca08c57b85a7cc33c49aee7ed6ed414c2a6808db",
+        "s0_period": "c0febd608d078dc5a37e6842ae09a8ef9144f62fd3606bb4b8c0cd76fa05fd53",
+        "s1_period": "a5713c63fe0985d7c59b51c38833097bb5a67daae3c2920ef718229b79599b0b"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 82,
+        "s1_eos": 98,
+        "s0_period": 82,
+        "s1_period": 98
+      }
     },
     {
       "id": "gsm8k/test/0906",
@@ -957,7 +1557,7 @@
       "domain_index": 18,
       "selection_rank": "035256813697b847333e8d1e657ea0a5a2793a5f4fd79ec170bad08fc63feba2",
       "source_text_sha256": "da2760f4f2f38c084029728114c2017b9ae49d0bf21f8846968cd705038e9cd5",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "1027b164359b9f3f47bfab7a50fb8569a683fc12744ff9855d50080f93f60e9d",
         "s1_eos": "ff186a4390d6d398ae9143f515bf601aa9618c5da58564dc7da822411c1c9983",
         "s0_period": "92df0af9657b53897995f5990471c294b895f1bc81ea145185dcda1a09e2b95e",
@@ -967,7 +1567,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "c0c6b988c90ca351f3d16b43c329dff218f122e9e09019054007340b59f35477",
+        "s1_eos": "898314e08e48fc820b2c27fe9d9a1ea8a3944674c75148273a695b125a0f8154",
+        "s0_period": "f5982f5821deb2456df4032e65be24b4a31e8431ada06486d1496f20902a890e",
+        "s1_period": "8dc7598723e2edf15272584e70ef835bc83066b441d18f77cfa4cfc3e81df4b2"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 78,
+        "s1_eos": 94,
+        "s0_period": 78,
+        "s1_period": 94
+      }
     },
     {
       "id": "gsm8k/test/0092",
@@ -975,7 +1587,7 @@
       "domain_index": 19,
       "selection_rank": "036fc57b14ee989e00cea584e28add4f5123d84b4e632c7b777aa2b410ac2c4e",
       "source_text_sha256": "30e10116f95bb87840ace44d50ad933c09d0937a25baa8d8f80c76bd7535350a",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "a37064b7eda6a5b5d6ef875fa6f1edd37376ad88469ba4f4f667a8076c22f775",
         "s1_eos": "76196d53d00bc859ac346e9f7ea59efe96685a34408ef2f7b703d9b2ec7e10e5",
         "s0_period": "df8f8eebd79aa074157eb109425ca8b1d055dcd8ae92b75ca6a592c7dd984c21",
@@ -985,7 +1597,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "d002b6d7f327797d83282f5b7341cbfaf3d34d2af359d7cb88dd547182bd666c",
+        "s1_eos": "4e8448e75d26b4d69a3f4667dec227d7e232b309c2cab3fb265a4edbee1fb3bc",
+        "s0_period": "d06711c090778e3019b41139f1319fae9793a5d1a8508c85ab6f84667438df5b",
+        "s1_period": "b530c55eae02136d524ca3938cb777bb54c68a8f9226f56f281f5676152a096a"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 75,
+        "s1_eos": 91,
+        "s0_period": 75,
+        "s1_period": 91
+      }
     },
     {
       "id": "gsm8k/test/0372",
@@ -993,7 +1617,7 @@
       "domain_index": 20,
       "selection_rank": "038cd03fb9104a796adae4930a3b7eae24ea07906d0789b3ceecda2a338b3714",
       "source_text_sha256": "7810cb6f7d1e2ec732197a85f05988002b179c41adfcc03895d287e4568c53b5",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "12dde598aa845bf02694415058832208c0ad5f75147a84855daff1885325146a",
         "s1_eos": "fd202f3e2769ab73d59ce5e9a5cb80f5a239cda4a3f1106eb6a2cfa208086ba9",
         "s0_period": "ae25372851d8574023b245924596f8e0b58e52822469f0c6bbd51c44cde10619",
@@ -1003,7 +1627,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": true
+      "independent_replay": true,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "1da97d92811f80138a65295ddbbc96ff3f08a5ea5154f14ecaa09996ff9cc28e",
+        "s1_eos": "dcd7dbde77f0a508cc0300b462237203873053146a6a711fb463931395e83157",
+        "s0_period": "0e4e785de08afa4e7cf9adb609b6f260991c0a93c34fbedb331a5acd988fa023",
+        "s1_period": "b24187ffbe434e47eb1fb44bac03b1b0c6743610f5ae6d48d1335116729cca43"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 74,
+        "s1_eos": 90,
+        "s0_period": 74,
+        "s1_period": 90
+      }
     },
     {
       "id": "gsm8k/test/0361",
@@ -1011,7 +1647,7 @@
       "domain_index": 21,
       "selection_rank": "03b08b85b81888c5fc1033dfd9c132aa147d5bb85d486cf32917c01a8ae5f54a",
       "source_text_sha256": "de5d935c56ce69df276b4d84b4af6a6aeeea6521cbae8a75e66cc2b106be8550",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "9d39ec1e0da4c43efed250caf61b4f258dd438a60553cfec7b01d304d31adafb",
         "s1_eos": "999cd4ffd587795760546118a06c3281736dc8f682e9aeda8dc6b8e559c01161",
         "s0_period": "47cbba12fe460791b8fa583ca1b201763473dd775f0fd7a2b6ea5174ba77f5db",
@@ -1021,7 +1657,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "94d310bb0df1a42cabbe0d68c60fc8ddc75da51b77feddd9c118396c3a0c35a1",
+        "s1_eos": "b153d1d73987f82a78ea279ce3b9b4a7f07b697ead1028824651ce2ae22da2e1",
+        "s0_period": "58400f45186d8bd7ccc1d4aa8c1b5f877ba27dff4a2c25abd7372fd7b7ade9d8",
+        "s1_period": "99393ce4ef0b1785d8a1c0a10dbdcf4952313a99a24684bdc475c251a793543e"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 119,
+        "s1_eos": 135,
+        "s0_period": 119,
+        "s1_period": 135
+      }
     },
     {
       "id": "gsm8k/test/0733",
@@ -1029,7 +1677,7 @@
       "domain_index": 22,
       "selection_rank": "04307c4d732dcd9b5fe573fa99772baab669acca379a641ed9df72ef2ed18dc2",
       "source_text_sha256": "26e868b2ce725fc01164e8efcad60d8de755341dde1b5bd001e7fc9815f43197",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "978117c99ac8e08204be65dd4a6b5646f008f5c282fccaea5678fa4c3a7c52af",
         "s1_eos": "9b25e7e2923fa80396876c50640cbd85d4fd016b1dc9299abbc2daf4500dd5c1",
         "s0_period": "4ee821d82e8d87c60641e61e3fe051a53f7bb8da4297b9423412df58fa6ef549",
@@ -1039,7 +1687,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "c16ec588e84920c3255658623fd6d8ee9fecbf6b9aaba404e7a04b87b6bf24b8",
+        "s1_eos": "fda4dc4f19d0c72afdd7f36122c8895434b0fff19a50cfad37244b3e343c68b3",
+        "s0_period": "a216ae3aeebe141aaeb9facef150ab2880e4278ed166aae9bed86c6d7b81c2b7",
+        "s1_period": "c207349f18d835dcba9e2e9357b4b861a0b1381b5caa5880c4de39b7e2dfe646"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 66,
+        "s1_eos": 82,
+        "s0_period": 66,
+        "s1_period": 82
+      }
     },
     {
       "id": "gsm8k/test/0687",
@@ -1047,7 +1707,7 @@
       "domain_index": 23,
       "selection_rank": "049c5780de56bc8eef319b50fcb3db8b66919b5af48f1c335b4ef15bfc0dbe13",
       "source_text_sha256": "8442b01bf873cb623d48ce23f5616a670fbca07b2898cd258d6fe9de0ea1890c",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "9c13a3554c65bbdc9fa30d3cabad7eb7b7b26c1a47f205b879f96e54533c08f6",
         "s1_eos": "73902fd1a27a1d5e582e7f6f8875515090b4e2176ac622c70e59eada9545af94",
         "s0_period": "5e304cd15cf44d3a5338620923e21f78abd6c9564987475f442010eef108703a",
@@ -1057,7 +1717,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "8ad9452346f7e7868979b6b880060070275843ec5c75e212bd98547652f73ab9",
+        "s1_eos": "af1fde1aca8b49f027dd5ed66a40adbd98f1ac28dc3e77b0f42c691db7cd595a",
+        "s0_period": "84fed23931e5c271038b376c50eac7b2449f998531be2c8eb2d238b624742b1f",
+        "s1_period": "b54476ed20b4929d881977e225e0a246bd26bd38c480593cf54e748d8911f684"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 64,
+        "s1_eos": 80,
+        "s0_period": 64,
+        "s1_period": 80
+      }
     },
     {
       "id": "gsm8k/test/0584",
@@ -1065,7 +1737,7 @@
       "domain_index": 24,
       "selection_rank": "04a3de37eb106ccbfa9f152f977fccdaf9d81c408628f36b02af7eac2a762488",
       "source_text_sha256": "9f45de87481deed78ce0cc5d36b78a3bcf6da872c193524d1ec968613145e29d",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "b57e1a8f185bbee5b8c67782aad0df686380ea73509d18a987510035de2e916f",
         "s1_eos": "95baf28aa3e9b6bde673683fbd39990c9bc68cd9e81b276f7a6969874449469d",
         "s0_period": "752382469a45e49b721b5c52a9d7a281fc795fe0a98351eb102787e73f154fec",
@@ -1079,7 +1751,19 @@
         "T2",
         "T3"
       ],
-      "independent_replay": true
+      "independent_replay": true,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "34fb132edd633648f7d10da8378bb2c8f72632d274959d1db5fc8a70399c786d",
+        "s1_eos": "ad076b8f47f0ee4c289a6db262490bc6f7eb603c46864e4fe2b9b512e56e857e",
+        "s0_period": "bc813cda32f64b7749206be3d9705ad20c29336cb37ae7222a84b1f91cd01d51",
+        "s1_period": "93038821b651753d36036db6907e535f920d4fab96dd48ecedf4771382a053c5"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 82,
+        "s1_eos": 98,
+        "s0_period": 82,
+        "s1_period": 98
+      }
     },
     {
       "id": "gsm8k/test/1152",
@@ -1087,7 +1771,7 @@
       "domain_index": 25,
       "selection_rank": "04d2980a7e76a708be593d0b47ddfcc9926307894f4c20532fa44f1bdf4a48de",
       "source_text_sha256": "fedfc30ae73a9f3a9b142acac32bd214a14407c73079c107076740f8db8fb09d",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "fb8109d835341a038d61c4bb4c864b1768b2b65b78e8bec0cb5cb788ee7497c5",
         "s1_eos": "fb8562da582f8ff10b0b66588b29f99797d1fab401b024fe26745dd63347d3c4",
         "s0_period": "5a561a45f504b224be21fbec6e15312b3c5fa27980d364ab6ff37c524640a22b",
@@ -1097,7 +1781,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "6705b75c72c171058ea3572f7f22210d64a08b34dbce2a678490575180a9ff01",
+        "s1_eos": "c25b1b78ce1490d04496dc93cde1b45a280e6358dece80fc45d009d9819e8914",
+        "s0_period": "dec2c59417d8a5882f08148c0c7fb19c3e3e5c4a3e705a82113ab31d0acb53f4",
+        "s1_period": "fac00b4ab8e59078d9bbf61ab3d8b4b9f24a20fb941e32b5dd180b5970df5ca2"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 69,
+        "s1_eos": 85,
+        "s0_period": 69,
+        "s1_period": 85
+      }
     },
     {
       "id": "gsm8k/test/1021",
@@ -1105,7 +1801,7 @@
       "domain_index": 26,
       "selection_rank": "04fd8b0beeb0af5582a86211ab7ac01a357f50edb59c6e0a6cabfd64b17639e0",
       "source_text_sha256": "d30137acb2e87d30e7d3bebd3a78fe421fd33ed3dad252262c0805ed83b73cd0",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "776c7c476253fb5467b2f5f4f2848b110aa81c5d0a8a734ac942735518454a30",
         "s1_eos": "c4f23828df7e618026256de39e847ae60fdc7f586e1dca024d06310ef9058a08",
         "s0_period": "bacc5126dc02832423e31e973369a21e9da891aa8eb670c271107064c9be7f5a",
@@ -1115,7 +1811,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "a97f54d38d8bfff3f24eb5a0c75ae1f2deb5ae77afbd87deda439a880db45c1a",
+        "s1_eos": "66ff6bc3c2bf0a90d917abf1d58df7ffe8ac085bafe9d8a67bff335bdfdb9f18",
+        "s0_period": "e25d1565828c123d868987a13a0d6798fcc3ab535e0cd2df89bd9131f4f2a99f",
+        "s1_period": "2a1174de73d7067868df9c8e8868ff8f7719ce64ff9b5464bdc5ae5bf1973e9c"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 90,
+        "s1_eos": 106,
+        "s0_period": 90,
+        "s1_period": 106
+      }
     },
     {
       "id": "gsm8k/test/1194",
@@ -1123,7 +1831,7 @@
       "domain_index": 27,
       "selection_rank": "0514f7f9fc1da8490ae0b11068cd65dd3c1ab52e51471ac3fb024b9d56631806",
       "source_text_sha256": "403c14d7e3268a34e7db02d081f0111ca60985533e231e07ab8787d3b58d03c3",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "fbd53689e2013696720f5c5e00238b3910a483885c759d6b00936864f467e434",
         "s1_eos": "c9b6f3a0501f5993263169d3a8335ae791829b8b5f93a270721f8af1383f6df9",
         "s0_period": "5d7798232a7c354df094c71470d7e78183f931a104be9c1bf91d34f603d486ee",
@@ -1133,7 +1841,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "2e2474fadf83a9e0ec1f61de368962a9db68179eb6fb5abf7f42e97ce74a2c43",
+        "s1_eos": "4e605004c39f7a0c9374edf9c532b464528cd92b6b187d59052d25475226fb1a",
+        "s0_period": "a4534ef6827a972f988fdf10ee379a3955dff62d9f52fa51faafb4118684df7e",
+        "s1_period": "53870d0f17edb4f05d480b27de60a1e24e87d712d634f5cae134e440afa0a36a"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 78,
+        "s1_eos": 94,
+        "s0_period": 78,
+        "s1_period": 94
+      }
     },
     {
       "id": "gsm8k/test/0399",
@@ -1141,7 +1861,7 @@
       "domain_index": 28,
       "selection_rank": "057d0b8ed707d05f39d4fa70b905e8a3a60efc7f6c35cc3ffd4fdacd16bde7eb",
       "source_text_sha256": "bfa0079a8897430238b73ceca009014d55719a9fa8e21000051ab05a8f3eee88",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "9be80fec516ddc66691d40176639c448785feb8c1bb69d521da1dfbfd35b3e83",
         "s1_eos": "cd28894f20e682b2714baa4a4dec7f7e1f04b29fba9bf30a56ec289759d09a67",
         "s0_period": "06199208f8f44a0b9070260b68e10c3863418bc5731eb24fd8077ca1781c439b",
@@ -1151,7 +1871,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": true
+      "independent_replay": true,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "47f3dba39fdb7d42d3edd7325a9e18b749de9591013b52eea9873513a3a3be29",
+        "s1_eos": "b9cfdb5538647577f63cb600079f26710f5adee4b18f1170469e323018d3d71a",
+        "s0_period": "4239198ed41ec8f995c30031e348694447dad4332cd997f84fb1c184759a0a6f",
+        "s1_period": "8775947578322aa92d8b37f379d648573b54ae61549c77ec01a352d6c8189de0"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 63,
+        "s1_eos": 79,
+        "s0_period": 63,
+        "s1_period": 79
+      }
     },
     {
       "id": "gsm8k/test/0214",
@@ -1159,7 +1891,7 @@
       "domain_index": 29,
       "selection_rank": "069590875c372687074281a45b22de709b7628b30d4cc5f7a53ce2f331c529f3",
       "source_text_sha256": "13ddeb54e970018f1030ba0963d8195825f540a6f0eef5e66367a8d4d435ea29",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "8c5060bdc697da2bec8c253ef438d5a12d26cf421131e2cb8846bd8e982054d5",
         "s1_eos": "cbc818448c42da48997bad65889294ddec0c481d7695045c7fdb82345309b4f8",
         "s0_period": "72a8c2af8c0e2af37bbfb91ed2bd25d0b5cc8948c47350fcfc241816099b950e",
@@ -1169,7 +1901,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "3d4b020d1ecf96c8191946dcf519d623abce29b85cc0b9015af7d35912de38f0",
+        "s1_eos": "7c73011d21e0252224687d613c48510eaf31ec208d2a28817930a9f8bf5a8f86",
+        "s0_period": "883623327630e3fa4ca26f2d8a2ee97ad96550bc860f2d71987e014e72c30e0f",
+        "s1_period": "1e9cd344b594ff2b8f10956a8305db6a475fed55e142d041228fcdd99d3972e8"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 86,
+        "s1_eos": 102,
+        "s0_period": 86,
+        "s1_period": 102
+      }
     },
     {
       "id": "gsm8k/test/1084",
@@ -1177,7 +1921,7 @@
       "domain_index": 30,
       "selection_rank": "06c58df5fb898da5f9546423dcfc2087a617b6a06a6c616972f8552e9f7aa489",
       "source_text_sha256": "3c7ee3f0b13b459809461336522fcde2dc36c4d5471d24717a62f47e4e313255",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "8c823af214d1fb1364776a261f69e41a2fdba56e7727d6df6ce73be8d5df44c3",
         "s1_eos": "21ec3767df8846cc1974cd8cc147fd6b1405e7fb9a91126cd0ef9576ba16df1e",
         "s0_period": "8dbd28fce4dc52cd3d61fb267cead976b2a701dfadc08484d6368f13a93875d7",
@@ -1187,7 +1931,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "ef0692c3c194665f05eb3e639f6c19bdc1c7d98d6fa3e7ab910632a43ce537f2",
+        "s1_eos": "d69adb22e72379a288fbe7a075dfae7c553f1cd372b4e1338506f1fff11de49c",
+        "s0_period": "ec1de2a15f0862db8813a6fe6dc38393d545c56aa2e81bfaf5b9a0c7bc7ba085",
+        "s1_period": "bf76b11c64ed89bbbc3c99b59b209b018067babb9eee02f83de67863c9a787bb"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 64,
+        "s1_eos": 80,
+        "s0_period": 64,
+        "s1_period": 80
+      }
     },
     {
       "id": "gsm8k/test/0964",
@@ -1195,7 +1951,7 @@
       "domain_index": 31,
       "selection_rank": "06d23587754d564944074e12dcaccf0ab91e70a3eafddf832d30f2553730d38a",
       "source_text_sha256": "31c70fdf274828397d34824e8342ec13a0e3c45714f337ae0ae0d8aed2272e0f",
-      "prompt_token_ids_sha256": {
+      "routing_probe_prompt_token_ids_sha256": {
         "s0_eos": "04fb0dd44388cfc0cf0de77e5d4c38070914ba2d309b5170b210f4600d8999cd",
         "s1_eos": "89925b195626bfe80411cf8665d38f29a715ba391c07a04f5f3548137735b091",
         "s0_period": "26c81bf993324fdedbbcd85e3bc3cf85fb468d79f0b2e635d575b92eeeec9724",
@@ -1205,7 +1961,19 @@
         "T0"
       ],
       "diagnostic_tapes": [],
-      "independent_replay": false
+      "independent_replay": false,
+      "chat_generation_prompt_token_ids_sha256": {
+        "s0_eos": "892751b6abe5d70f7864406f76397c01f879f2859f0013733778d206da5fdc53",
+        "s1_eos": "f185d59076dc83615e2dea09338c4ddd7a39a57d4ca2a43a367a7a118f94ffd4",
+        "s0_period": "985e360aa6163b97ab5a4f3fba97a707db2643155fe4c1c320ae24ed6f9dcb61",
+        "s1_period": "3312c2f256d21ea9f631c4c0ec6fbd3932c071100b8bc7abd03e957ece725ebb"
+      },
+      "chat_generation_prompt_tokens": {
+        "s0_eos": 74,
+        "s1_eos": 90,
+        "s0_period": 74,
+        "s1_period": 90
+      }
     }
   ],
   "source_counts": {
@@ -1300,5 +2068,12 @@
     "tape_bootstrap_seed": 980269685,
     "estimand_boundary": "Selected-task resampling bands for this fixed 32-task frame and one frozen tape; not benchmark-population or generation-seed confidence intervals."
   },
-  "canonical_content_sha256": "42ec988585d34ce9c2a193dd59a30a7f549d8a67b768c17098aaf3f30ca73804"
+  "prompt_contract": {
+    "routing_probe_hashes_are_not_chat_generation_hashes": true,
+    "chat_generation_hashes_frozen": true,
+    "chat_generation_prompt_cells": 256,
+    "chat_generation_prompt_hashes_sha256": "7f766be54463c7f513948dd6d63a55e12b85b9220ee177361c743cd9997f6c3b",
+    "renderer": "official apply_chat_template followed by the frozen single boundary-ID edit for period cells"
+  },
+  "canonical_content_sha256": "d15303e18345f6dec2aaf891ba812c0a0232b86f416f8f685eabbe818249e838"
 }
diff --git a/research/DEEPSEEK_V2_LITE_CHAT_TASK_BOOTSTRAP_PROTOCOL.md b/research/DEEPSEEK_V2_LITE_CHAT_TASK_BOOTSTRAP_PROTOCOL.md
index a4cf90d..20fd407 100644
--- a/research/DEEPSEEK_V2_LITE_CHAT_TASK_BOOTSTRAP_PROTOCOL.md
+++ b/research/DEEPSEEK_V2_LITE_CHAT_TASK_BOOTSTRAP_PROTOCOL.md
@@ -2,6 +2,14 @@
 
 > 状态：**已预注册，尚未运行本协议的任何生成输出**
 >
+> 预运行修订 1：实现审查后把“四条 trajectory 逐条执行”改为固定四行 batch；取样仍由
+> 每步显式共享的 `u_t` 完成。修订发生在任何 smoke / 正式输出之前，只为避免四倍重复
+> forward；finished row 的后续 PAD=EOS 与 mask=0 合同同时冻结在下文。
+>
+> 预运行修订 2：tokenizer-only 闸门发现首版 manifest 误把路由探针的短输入 hash 标成
+> Chat 生成 prompt hash。此时模型尚未加载、协议输出仍为 0。清单保留路由 hash，并新增
+> 由正式 Chat renderer 产生的 256 个 prompt hash；runner 只核验后者。
+>
 > 注册日期：2026-07-30
 >
 > 协议 ID：`llm-atlas-deepseek-chat-task-bootstrap-crn-v1`
@@ -10,10 +18,13 @@
 > `research/DEEPSEEK_V2_LITE_CHAT_TASK_BOOTSTRAP_MANIFEST.json`
 >
 > 清单文件 SHA-256：
-> `7f5ef75f8e4bade35875e9132ea16f25f7fdb54450490e07cf1f6b2f701fceac`
+> `6313e70536c464fe598a93035576752418f08016dfd60ac246437c3b43bf2ae1`
 >
 > 清单规范内容 SHA-256：
-> `42ec988585d34ce9c2a193dd59a30a7f549d8a67b768c17098aaf3f30ca73804`
+> `d15303e18345f6dec2aaf891ba812c0a0232b86f416f8f685eabbe818249e838`
+>
+> 256 个 Chat prompt 合同 hash：
+> `7f766be54463c7f513948dd6d63a55e12b85b9220ee177361c743cd9997f6c3b`
 
 ## 0. 一句话说明这一轮
 
@@ -93,8 +104,9 @@ s0_eos, s1_eos, s0_period, s1_period
 - 其余 prompt token 与前序冻结模板相同；
 - 每条 prompt token hash 必须与冻结清单逐格 exact。
 
-正式生成不是四行 batch。四条 trajectory 逐条执行，以避免一个条件先 EOS 后 batch
-padding / RNG 调用对其他条件产生隐式影响。
+正式生成使用固定四行 batch，行序即上述条件序。batch 内没有跨行 attention；取样不调用
+PyTorch RNG。同一行结束后，后续步追加 PAD=EOS 且该位置 attention mask 为 0，其他仍活跃
+行继续 forward。这个合同避免四倍重复 forward，也把执行形状固定下来。
 
 ---
 
@@ -196,7 +208,9 @@ u_t = (z_t + 0.5) / 2^64
 4. 按 token ID `0..vocab-1` 做 `torch.float32` cumulative sum；
 5. 强制最后一个 CDF 元素为 `1.0`；
 6. 将 `u_t` cast 为 `torch.float32`；
-7. `torch.searchsorted(cdf, u_t, right=False)` 取得 token ID。
+7. float32 转换若落在端点，则 clamp 到
+   `torch.nextafter(0,1)` / `torch.nextafter(1,0)`；
+8. `torch.searchsorted(cdf, u_t, right=False)` 取得 token ID。
 
 因此：
 
@@ -249,6 +263,7 @@ smoke 不进入正式统计。
 - 每题结束后写独立 journal；再次启动时必须核验协议、source、prompt 与输出内容 hash 后才
   能 resume；
 - journal 只用于可恢复执行，正式 JSON 由全部合格 journal 组装。
+- 四格固定同 batch；finished row 在后续步追加 PAD=EOS、对应 attention mask 为 0。
 
 ### 5.3 跨进程独立重放
 
diff --git a/scripts/build-deepseek-chat-task-bootstrap-manifest.mjs b/scripts/build-deepseek-chat-task-bootstrap-manifest.mjs
index 509a2b0..3efe8a6 100644
--- a/scripts/build-deepseek-chat-task-bootstrap-manifest.mjs
+++ b/scripts/build-deepseek-chat-task-bootstrap-manifest.mjs
@@ -81,7 +81,7 @@ const sources = DOMAINS.flatMap((domain) => {
       domain_index: domainIndex,
       selection_rank: row.selection_rank,
       source_text_sha256: row.text_sha256,
-      prompt_token_ids_sha256: promptHashes,
+      routing_probe_prompt_token_ids_sha256: promptHashes,
       main_tapes: ["T0"],
       diagnostic_tapes: DIAGNOSTIC_INDICES.has(domainIndex)
         ? ["T1", "T2", "T3"]
@@ -175,6 +175,11 @@ const manifest = {
     estimand_boundary:
       "Selected-task resampling bands for this fixed 32-task frame and one frozen tape; not benchmark-population or generation-seed confidence intervals.",
   },
+  prompt_contract: {
+    routing_probe_hashes_are_not_chat_generation_hashes: true,
+    chat_generation_hashes:
+      "Added by freeze-deepseek-chat-task-bootstrap-prompts.py before any protocol output.",
+  },
 };
 
 manifest.canonical_content_sha256 = sha256(canonical(manifest));
diff --git a/scripts/freeze-deepseek-chat-task-bootstrap-prompts.py b/scripts/freeze-deepseek-chat-task-bootstrap-prompts.py
new file mode 100644
index 0000000..05e74ff
--- /dev/null
+++ b/scripts/freeze-deepseek-chat-task-bootstrap-prompts.py
@@ -0,0 +1,172 @@
+#!/usr/bin/env python3
+"""Freeze all 256 Chat-generation prompt hashes into the Round 08 manifest."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import sys
+from pathlib import Path
+from typing import Any
+
+
+ROOT = Path(__file__).resolve().parents[1]
+DEEPSEEK_EXPERIMENTS = ROOT / "experiments" / "deepseek"
+sys.path.insert(0, str(DEEPSEEK_EXPERIMENTS))
+
+from transformers import AutoTokenizer  # noqa: E402
+
+import v2_lite_chat_special_token_behavior_probe as behavior  # noqa: E402
+import v2_lite_routing_special_token_family_control as special  # noqa: E402
+
+
+PROTOCOL_ID = "llm-atlas-deepseek-chat-task-bootstrap-crn-v1"
+CONDITIONS = (
+    "s0_eos",
+    "s1_eos",
+    "s0_period",
+    "s1_period",
+)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--artifact-dir", type=Path, required=True)
+    parser.add_argument("--manifest", type=Path, required=True)
+    parser.add_argument(
+        "--reference-routing-json",
+        type=Path,
+        required=True,
+    )
+    parser.add_argument("--human-eval", type=Path, required=True)
+    parser.add_argument("--gsm8k", type=Path, required=True)
+    parser.add_argument("--tnews", type=Path, required=True)
+    parser.add_argument("--tnews-archive", type=Path, required=True)
+    parser.add_argument("--wikitext", type=Path, required=True)
+    return parser.parse_args()
+
+
+def canonical_hash(value: Any) -> str:
+    return hashlib.sha256(
+        json.dumps(
+            value,
+            ensure_ascii=False,
+            sort_keys=True,
+            separators=(",", ":"),
+        ).encode()
+    ).hexdigest()
+
+
+def install_condition_contract() -> None:
+    factors = {
+        condition: special.FACTORS[condition]
+        for condition in CONDITIONS
+    }
+    special.BOUNDARY_LEVELS = ("eos", "period")
+    special.CONDITIONS = CONDITIONS
+    special.FACTORS = factors
+    special.SYSTEM_CELLS = {
+        "eos": ("s0_eos", "s1_eos"),
+        "period": ("s0_period", "s1_period"),
+    }
+    special.SYSTEM_EDGE_CONTRASTS = {
+        "period_minus_eos": ("eos", "period"),
+    }
+    special.install_control_contract()
+
+
+def main() -> None:
+    args = parse_args()
+    manifest = json.loads(args.manifest.read_text(encoding="utf-8"))
+    if manifest["protocol_id"] != PROTOCOL_ID:
+        raise RuntimeError("manifest protocol ID differs")
+    install_condition_contract()
+    tokenizer = AutoTokenizer.from_pretrained(
+        args.artifact_dir,
+        trust_remote_code=True,
+        local_files_only=True,
+        use_fast=True,
+    )
+    if tokenizer.pad_token_id is None:
+        tokenizer.pad_token_id = tokenizer.eos_token_id
+    args.domains = ["code", "math"]
+    args.per_domain = 32
+    source_rows, _ = behavior.selected_sources(args, tokenizer)
+    frozen_rows = {
+        row["id"]: row for row in manifest["sources"]
+    }
+    audit = []
+    for source in source_rows:
+        frozen = frozen_rows.get(source["id"])
+        if frozen is None:
+            raise RuntimeError(f"{source['id']} is absent from manifest")
+        hashes = {}
+        tokens = {}
+        for condition in CONDITIONS:
+            rendered = special.prior.render_boundary_variant(
+                tokenizer,
+                source["content"],
+                condition,
+            )
+            hashes[condition] = rendered["token_ids_sha256"]
+            tokens[condition] = rendered["tokens"]
+            audit.append(
+                {
+                    "source_id": source["id"],
+                    "condition": condition,
+                    "tokens": rendered["tokens"],
+                    "sha256": rendered["token_ids_sha256"],
+                }
+            )
+        frozen["chat_generation_prompt_token_ids_sha256"] = hashes
+        frozen["chat_generation_prompt_tokens"] = tokens
+    if len(audit) != 256 or len(source_rows) != 64:
+        raise RuntimeError(
+            f"expected 64 sources / 256 cells, got "
+            f"{len(source_rows)} / {len(audit)}"
+        )
+    manifest["status"] = (
+        "preregistered_and_chat_prompt_hashes_corrected_before_"
+        "any_protocol_output"
+    )
+    manifest["prompt_contract"] = {
+        "routing_probe_hashes_are_not_chat_generation_hashes": True,
+        "chat_generation_hashes_frozen": True,
+        "chat_generation_prompt_cells": len(audit),
+        "chat_generation_prompt_hashes_sha256": canonical_hash(audit),
+        "renderer": (
+            "official apply_chat_template followed by the frozen "
+            "single boundary-ID edit for period cells"
+        ),
+    }
+    manifest.pop("canonical_content_sha256", None)
+    manifest["canonical_content_sha256"] = canonical_hash(manifest)
+    args.manifest.write_text(
+        json.dumps(manifest, ensure_ascii=False, indent=2) + "\n",
+        encoding="utf-8",
+    )
+    payload = args.manifest.read_bytes()
+    print(
+        json.dumps(
+            {
+                "manifest": str(args.manifest),
+                "bytes": len(payload),
+                "sha256": hashlib.sha256(payload).hexdigest(),
+                "canonical_content_sha256": manifest[
+                    "canonical_content_sha256"
+                ],
+                "sources": len(source_rows),
+                "prompt_cells": len(audit),
+                "prompt_hashes_sha256": manifest["prompt_contract"][
+                    "chat_generation_prompt_hashes_sha256"
+                ],
+            },
+            ensure_ascii=False,
+            indent=2,
+        )
+    )
+
+
+if __name__ == "__main__":
+    main()