#!/usr/bin/env python3
"""build_demo_episodes.py — run_pick_place の記録から π0.5 学習用エピソードを作る (Mac 側・段階1).

入力 (1 試行 = 1 run_stem):
  runs/run_pick_place/{run_stem}/{run_stem}.json      判定 (judgments.pick/place.human_verdict)
  runs/run_pick_place/{run_stem}/recording/states.csv  actual (実測6軸) / gripper_cmd / stage 行
  runs/run_pick_place/{run_stem}/recording/top.mp4 + top_frame_log.csv  上カメラ
  (recorder.py --top と run_pick_place.py --record-demo で記録したもの)

出力 (1 エピソード = 1 フォルダ):
  datasets/{DATASET}/raw_episodes/{run_stem}/
    frames/000000.jpg ...   上カメラ (長辺 IMG_LONG px, 縦横比維持)
    episode.npz             t[N], state[N,7], actions[N,7]   (7 = j0..j5 [deg] + gripper 0/1)
    meta.json
  datasets/{DATASET}/index.json   採用/不採用とその理由

設計:
  - 時間軸は FPS (10Hz) で並べ直す.
  - state: 実測角 (約3Hz) を線形補間. gripper は指令した瞬間で 0→1 / 1→0 に切替.
  - action: 0.1 秒後の state (絶対角). π0.5 は action chunk でこれを予測する.
  - 停止区間 (動き < IDLE_EPS_DEG が IDLE_MAX_SEC 超) は先頭 IDLE_KEEP_SEC だけ残して詰める.
    検出・VLM・人の入力待ちを「待つ動作」として学習させないため.
  - --trim-mid-idle を付けると、上の処理で残った停止区間もさらに先頭
    MID_IDLE_KEEP_STEPS だけ残して詰める (DAY288. mid_idle_keep_mask を参照).
    このとき 関節 6 列の action を残ったステップで作り直し、t を等間隔に振り直して
    元の時刻を t_orig に残す. オプション未指定時の出力は従来と同一.
  - グリッパー切替ステップの前後 (i-1, i, i+1) は どちらの停止詰めでも必ず残す.
  - 採用条件: pick と place の人の判定がどちらも yes (既定). VLM 判定は使わない.

Usage:
  python3 pi05/build_demo_episodes.py                # 2026-10-15 以降の全試行
  python3 pi05/build_demo_episodes.py --since 20261020 --dataset mecharm_redblock_box_scripted_v1
  python3 pi05/build_demo_episodes.py --run run_0001_20261015_180000 --force
  python3 pi05/build_demo_episodes.py --dataset mecharm_redblock_box_teach_v1_trim \
      --trim-mid-idle --since 20261019   # 途中の停止を先頭2ステップまで詰める
"""
import argparse
import csv
import json
import shutil
import sys
from pathlib import Path

import cv2
import numpy as np

DATA_ROOT = Path("/Volumes/KIOXIA/r2r2r-data")
RUNS_ROOT = DATA_ROOT / "runs" / "run_pick_place"
DEFAULT_DATASET = "mecharm_redblock_box_scripted_v1"
TASK = "put the red block in the white box"
FPS = 10
IMG_LONG = 384            # 保存画像の長辺 px. openpi 側で 224x224 に resize_with_pad される
JPEG_QUALITY = 95
IDLE_EPS_DEG = 0.3        # 1 ステップでの最大関節変化がこれ未満なら「停止」
IDLE_MAX_SEC = 2.0        # これより長い停止区間は詰める
IDLE_KEEP_SEC = 1.0       # 詰めるときに残す長さ
# --trim-mid-idle (DAY288) 用. 既定 (オプション未指定) では一切使わない。
MID_IDLE_EPS_DEG = 0.3    # 6 関節すべての |action - state| がこれ未満 かつ
                          # グリッパーの action == state なら「停止ステップ」
MID_IDLE_KEEP_STEPS = 2   # 連続する停止区間で残す先頭ステップ数
# codex レビュー R1: 1 ステップの変化だけで見ると「0.2°ずつ動き続ける区間」も
# 停止として削れてしまう。区間の先頭 state からのずれがこれを超えたら区間を切る。
MID_IDLE_DRIFT_DEG = 0.5
GRIPPER_GUARD_STEPS = 1   # グリッパー切替ステップ i の前後 i-1, i, i+1 を必ず残す
ANGLE_ABS_MAX = 200.0     # 実測値のサニティ (これを超えたら読み取り異常として捨てる)
MIN_ACTUAL_SAMPLES = 20

# LOG352 (2026-10-19): 試行の状態で採否を決める。
# 人の yes/yes だけでは「爪が開いたか不明な試行」を弾けない
# (codex R3 A9)。record_teach_demo.py は
#   result: completed / aborted / interrupted / error
#   gripper_state_uncertain: True (gripper の指令失敗 or 開いたか確認できなかった)
# を試行 JSON に残すので、それを見て除外する。
#
# OK_RESULTS に "completed_with_failures" を入れているのは **既存データを
# 落とさないため**。run_pick_place.py はステージ単位の失敗があっても完走すると
# この値を入れる。2026-10-19 実測で、mecharm_redblock_box_scripted_v1 の
# 採用 20 本のうち **15 本が completed_with_failures** だった
# (残り 5 本が completed)。人の判定は 20 本すべて yes/yes。
# "completed" だけに絞ると既存データセットが 20 本 -> 5 本に減ってしまう。
# run_pick_place.py 側の失敗は stage_failures に残り、最終的な採否は
# 人の判定が正である、という既存の運用をそのまま維持する。
OK_RESULTS = ("completed", "completed_with_failures")
# 古い試行 JSON には result が無いことがある。その場合は従来どおり
# 人の yes/yes だけで決める (後から基準を変えて過去を落とさない)。


def ensure_ssd():
    """KIOXIA のマウントを確認する (codex レビュー R5).

    DATA_ROOT.exists() だけでは、SSD 未マウントのまま /Volumes/KIOXIA/... が
    ローカルのディレクトリとして存在する場合を見抜けず、SSD だと思って
    内蔵ディスクへ書いてしまう。マウントポイント自体を is_mount() で見る。
    """
    mount = Path("/Volumes/KIOXIA")
    if not mount.is_mount():
        sys.exit(f"[ABORT] KIOXIA not mounted: {mount}")
    if not DATA_ROOT.exists():
        sys.exit(f"[ABORT] data root not found: {DATA_ROOT}")


def load_states(path):
    actual_t, actual_q, grip_t, grip_s = [], [], [], []
    with path.open(newline="") as f:
        for row in csv.DictReader(f):
            ev = row.get("event_type")
            try:
                ts = float(row["ts"])
            except Exception:
                continue
            if ev == "actual":
                try:
                    q = [float(row[f"j{i}"]) for i in range(6)]
                except Exception:
                    continue
                if any(abs(v) > ANGLE_ABS_MAX for v in q):
                    continue
                actual_t.append(ts); actual_q.append(q)
            elif ev == "gripper_cmd":
                try:
                    grip_t.append(ts); grip_s.append(1.0 if int(float(row["gripper_state"])) == 1 else 0.0)
                except Exception:
                    pass
    return (np.array(actual_t), np.array(actual_q, dtype=np.float64).reshape(-1, 6),
            np.array(grip_t), np.array(grip_s))


def drop_spikes(t, q, max_jump_deg=40.0):
    """前後どちらとも max_jump_deg 以上離れた孤立点 (読み取り異常) を捨てる."""
    if len(t) < 3:
        return t, q
    keep = np.ones(len(t), dtype=bool)
    for i in range(1, len(t) - 1):
        a = np.max(np.abs(q[i] - q[i - 1])); b = np.max(np.abs(q[i] - q[i + 1]))
        c = np.max(np.abs(q[i + 1] - q[i - 1]))
        if a > max_jump_deg and b > max_jump_deg and c < max_jump_deg:
            keep[i] = False
    return t[keep], q[keep]


def load_frame_log(path):
    idx, ts = [], []
    with path.open(newline="") as f:
        for row in csv.DictReader(f):
            idx.append(int(row["frame_idx"])); ts.append(float(row["capture_ts"]))
    return np.array(idx), np.array(ts)


def judge(run_json):
    j = json.loads(run_json.read_text())
    jd = j.get("judgments") or {}
    pick_h = (jd.get("pick") or {}).get("human_verdict")
    place_h = (jd.get("place") or {}).get("human_verdict")
    return pick_h, place_h, j


def trial_state_reject_reason(j):
    """試行の状態から「学習に使えない理由」を返す. 使えるなら None (LOG352).

    - gripper_state_uncertain が真 -> 爪が開いた/閉じたかが不明。
      state[:, 6] のラベルが正しいと言えないので使わない。
    - result がある かつ OK_RESULTS に無い -> 中断した試行。
    - result が無い (古い試行 JSON) -> 従来どおり人の判定だけで決める。
    """
    if j.get("gripper_state_uncertain"):
        return "gripper_state_uncertain"
    res = j.get("result")
    if res is not None and res not in OK_RESULTS:
        return f"result={res}"
    return None


def _recording_disabled(run_dir):
    """試行 JSON が recording_enabled=False を明示しているか（LOG352）.

    読めない・キーが無い場合は False（従来どおり扱う）。
    """
    p = run_dir / f"{run_dir.name}.json"
    try:
        return json.loads(p.read_text()).get("recording_enabled") is False
    except Exception:
        return False


def gripper_switch_indices(state):
    """グリッパーが切り替わるステップの添字 (新しい値が最初に現れる添字) を返す."""
    if len(state) < 2:
        return np.empty(0, dtype=int)
    return np.flatnonzero(state[1:, 6] != state[:-1, 6]) + 1


def gripper_guard_mask(state):
    """グリッパー切替ステップ i の前後 (i-1, i, i+1) を True にしたマスク (codex R2).

    切替ステップそのものは `action[6] != state[6]` なので停止判定には入らないが、
    **切替の次のステップ (i, i+1)** は「関節が止まっていてグリッパーも変わらない」
    ステップなので停止として削除され得る。爪が閉じた/開いた直後の画像と state が
    消えると、グリッパーを動かす手がかりが学習データから落ちる。
    """
    n = len(state)
    guard = np.zeros(n, dtype=bool)
    for i in gripper_switch_indices(state):
        lo = max(0, i - GRIPPER_GUARD_STEPS)
        hi = min(n, i + GRIPPER_GUARD_STEPS + 1)
        guard[lo:hi] = True
    return guard


def mid_idle_keep_mask(state, actions):
    """停止区間を先頭 MID_IDLE_KEEP_STEPS だけ残す keep マスクを返す (DAY288).

    既存の「停止区間を詰める」処理 (IDLE_MAX_SEC=2.0 超) では、お手本の
    1.5〜2 秒の停止 (19〜20 ステップ) が閾値のすぐ下に収まって残っていた。
    π0.5 の action_horizon は 10 (1 秒) で停止より短いため、停止中は入力が
    変わらず「止まる」しか出せない → 実機でブロック真上から動かなくなる
    (記録: runs/pi05_policy/pi05_20261021_082645)。

    停止ステップの定義:
      - 6 関節すべてで |action - state| < MID_IDLE_EPS_DEG
      - かつ グリッパーの action と state が同じ

    codex レビュー R1: 上の条件は「1 ステップの変化」しか見ないので、
    0.2°ずつ動き続ける区間 (ゆっくりした動き) も停止と判定されてしまう。
    そこで停止区間の中でも、**区間の先頭 state からのずれ**が 6 関節のどれかで
    MID_IDLE_DRIFT_DEG を超えたら、そこで区間を切って新しい区間として数え直す。
    こうするとゆっくり動く区間は短い区間の連続になり、ほぼ削られない。

    グリッパー切替ステップの前後は gripper_guard_mask で必ず残す (codex R2)。
    先頭・末尾のステップも明示的に残す (エピソード両端の state を変えない)。
    """
    n = len(state)
    joint_still = np.max(np.abs(actions[:, :6] - state[:, :6]), axis=1) < MID_IDLE_EPS_DEG
    grip_same = actions[:, 6] == state[:, 6]
    idle = joint_still & grip_same

    keep = np.ones(n, dtype=bool)
    i = 0
    while i < n:
        if not idle[i]:
            i += 1
            continue
        # i から始まる停止区間を、先頭 state からのずれで切りながら進む
        anchor = i
        kept_in_region = 0
        while i < n and idle[i]:
            if np.max(np.abs(state[i, :6] - state[anchor, :6])) > MID_IDLE_DRIFT_DEG:
                anchor = i              # ここから新しい区間として数え直す
                kept_in_region = 0
            if kept_in_region < MID_IDLE_KEEP_STEPS:
                kept_in_region += 1     # 区間の先頭 MID_IDLE_KEEP_STEPS は残す
            else:
                keep[i] = False
            i += 1

    keep |= gripper_guard_mask(state)
    if n:
        keep[0] = True
        keep[-1] = True
    return keep


def build_one(run_dir, out_dir, args):
    stem = run_dir.name
    rec = run_dir / "recording"
    run_json = run_dir / f"{stem}.json"
    # LOG352: まず試行 JSON を読み、記録なしで走らせた試行をはっきり弾く。
    # record_teach_demo.py は --no-record で走らせると recording_enabled=False を残す
    # (段階C の検証はこれで走らせる)。映像が無いのでそもそもエピソードを作れない。
    # --include-failed でも迂回させない (分析用でも映像なしでは作れない)。
    if not run_json.exists():
        return {"run": stem, "used": False, "reason": f"missing:{run_json.name}"}
    try:
        trial = json.loads(run_json.read_text())
    except Exception as e:
        return {"run": stem, "used": False,
                "reason": f"run_json 読めない:{type(e).__name__}"}
    if trial.get("recording_enabled") is False:
        return {"run": stem, "used": False, "reason": "no_recording"}
    # LOG352 (codex R6 M3): グリッパーの開放確認ができない状態で取った試行を
    # **独立のゲート**で弾く。`gripper_state_uncertain` は「走行中に不明だった」
    # 試行しか捕まえられず、起動時に daemon が gv を読めなかった試行
    # (gripper_check.verified=false) は取りこぼす。
    # ABORT_IF_FIRST_OPEN_UNKNOWN を True へ戻し忘れたまま記録した場合の保険。
    # --include-failed でも迂回させない。キーが無い旧試行は従来どおり扱う。
    gc = trial.get("gripper_check")
    if isinstance(gc, dict) and gc.get("verified") is False:
        return {"run": stem, "used": False, "reason": "gripper_not_verified"}

    need = [rec / "states.csv", rec / "top.mp4", rec / "top_frame_log.csv"]
    missing = [p.name for p in need if not p.exists()]
    if missing:
        return {"run": stem, "used": False, "reason": "missing:" + ",".join(missing)}

    pick_h, place_h, trial = judge(run_json)
    if not args.include_failed and not (pick_h == "yes" and place_h == "yes"):
        return {"run": stem, "used": False, "reason": f"human_verdict pick={pick_h} place={place_h}"}
    # LOG352: 人の判定が yes/yes でも、試行の状態が不明/中断なら使わない
    if not args.include_failed:
        bad = trial_state_reject_reason(trial)
        if bad:
            return {"run": stem, "used": False, "reason": f"trial_state {bad}"}

    at, aq, gt, gs = load_states(rec / "states.csv")
    if len(at) < MIN_ACTUAL_SAMPLES:
        return {"run": stem, "used": False, "reason": f"actual 実測が少ない ({len(at)})"}
    order = np.argsort(at); at, aq = at[order], aq[order]
    at, aq = drop_spikes(at, aq)
    fidx, fts = load_frame_log(rec / "top_frame_log.csv")
    if len(fts) < FPS:
        return {"run": stem, "used": False, "reason": f"top フレームが少ない ({len(fts)})"}

    t0, t1 = max(fts[0], at[0]), min(fts[-1], at[-1])
    if t1 - t0 < 3.0:
        return {"run": stem, "used": False, "reason": "記録の重なりが短い"}
    t = np.arange(t0, t1, 1.0 / FPS)

    q = np.stack([np.interp(t, at, aq[:, k]) for k in range(6)], axis=1)
    g = np.zeros(len(t))
    if len(gt):
        go = np.argsort(gt); gt, gs = gt[go], gs[go]
        for i, ti in enumerate(t):
            k = np.searchsorted(gt, ti, side="right") - 1
            g[i] = gs[k] if k >= 0 else 0.0
    state = np.concatenate([q, g[:, None]], axis=1).astype(np.float32)
    actions = np.concatenate([state[1:], state[-1:]], axis=0)

    # 停止区間を詰める
    motion = np.max(np.abs(actions - state), axis=1)
    keep = np.ones(len(t), dtype=bool)
    i, idle_trim_steps = 0, 0
    while i < len(t):
        if motion[i] < IDLE_EPS_DEG:
            j = i
            while j < len(t) and motion[j] < IDLE_EPS_DEG:
                j += 1
            if (j - i) / FPS > IDLE_MAX_SEC:
                cut_from = i + int(IDLE_KEEP_SEC * FPS)
                keep[cut_from:j] = False
                idle_trim_steps += j - cut_from
            i = j
        else:
            i += 1
    # codex レビュー R2: グリッパー切替の前後 (i-1, i, i+1) はこの既存処理でも残す。
    guard = gripper_guard_mask(state)
    idle_trim_steps -= int((~keep & guard).sum())
    keep |= guard
    t, state, actions = t[keep], state[keep], actions[keep]

    # 途中の停止を縮める (--trim-mid-idle のときだけ). 既定では何もしない。
    steps_before_mid_trim = int(len(t))
    mid_idle_trimmed_steps = 0
    if args.trim_mid_idle:
        mkeep = mid_idle_keep_mask(state, actions)
        mid_idle_trimmed_steps = int((~mkeep).sum())
        t, state, actions = t[mkeep], state[mkeep], actions[mkeep]
        # codex レビュー R3: 削ったあとは「0.1 秒後の state」が隣のステップに
        # なっていないので、関節 6 列の action を残ったステップで作り直す。
        # グリッパー列 (actions[:, 6]) は元の指令のまま触らない。
        actions = actions.copy()
        actions[:-1, :6] = state[1:, :6]
        actions[-1, :6] = state[-1, :6]

    # 各ステップに最も近い上カメラのフレーム (frames は残したステップ分だけ書き出す)
    nearest = np.clip(np.searchsorted(fts, t), 1, len(fts) - 1)
    left = fts[nearest - 1]; right = fts[nearest]
    nearest = np.where(np.abs(t - left) <= np.abs(right - t), nearest - 1, nearest)
    want = {int(fidx[n]): [] for n in nearest}
    for step, n in enumerate(nearest):
        want[int(fidx[n])].append(step)

    if out_dir.exists():
        if not args.force:
            return {"run": stem, "used": True, "reason": "既存 (スキップ・--force で再生成)",
                    "steps": int(len(t))}
        shutil.rmtree(out_dir)
    (out_dir / "frames").mkdir(parents=True)

    cap = cv2.VideoCapture(str(rec / "top.mp4"))
    fi, written, max_need = 0, 0, max(want)
    size = None
    while fi <= max_need:
        ok, frame = cap.read()
        if not ok:
            break
        if fi in want:
            h, w = frame.shape[:2]
            s = IMG_LONG / max(h, w)
            small = cv2.resize(frame, (round(w * s), round(h * s)), interpolation=cv2.INTER_AREA)
            size = small.shape[1], small.shape[0]
            for step in want[fi]:
                cv2.imwrite(str(out_dir / "frames" / f"{step:06d}.jpg"), small,
                            [cv2.IMWRITE_JPEG_QUALITY, JPEG_QUALITY])
                written += 1
        fi += 1
    cap.release()
    if written != len(t):
        shutil.rmtree(out_dir)
        return {"run": stem, "used": False,
                "reason": f"フレーム抽出不足 written={written} steps={len(t)} (mp4 と frame_log の不一致)"}

    if args.trim_mid_idle:
        # codex レビュー R4: 詰めたあとの t は実時刻のままだと飛びがあり、
        # 「FPS 10 の等間隔」という前提と食い違う。等間隔に振り直し、
        # 元の時刻は t_orig に残す (どの瞬間を取ったか後から追えるように)。
        np.savez_compressed(out_dir / "episode.npz",
                            t=(np.arange(len(t)) / FPS).astype(np.float64),
                            t_orig=t - t[0], state=state, actions=actions)
    else:
        np.savez_compressed(out_dir / "episode.npz", t=t - t[0], state=state, actions=actions)
    meta = {
        "run_stem": stem, "task": TASK, "fps": FPS, "steps": int(len(t)),
        "duration_sec": round(len(t) / FPS, 1),
        "idle_trimmed_sec": round(idle_trim_steps / FPS, 1),
        "trim_mid_idle": bool(args.trim_mid_idle),
        "steps_before_mid_trim": steps_before_mid_trim,
        "mid_idle_trimmed_steps": mid_idle_trimmed_steps,
        "image_size": size, "state_dim": 7,
        "state_names": ["j0", "j1", "j2", "j3", "j4", "j5", "gripper"],
        "action": "absolute target = state 0.1s later",
        "actual_samples": int(len(at)), "gripper_cmds": int(len(gt)),
        "human_verdict": {"pick": pick_h, "place": place_h},
    }
    (out_dir / "meta.json").write_text(json.dumps(meta, indent=2, ensure_ascii=False))
    return {"run": stem, "used": True, "reason": "ok", "steps": int(len(t)),
            "idle_trimmed_sec": meta["idle_trimmed_sec"],
            "steps_before_mid_trim": steps_before_mid_trim,
            "mid_idle_trimmed_steps": mid_idle_trimmed_steps}


def assert_trim_target_is_new(ds):
    """--trim-mid-idle の出力先が「既存の非 trim データセット」なら ABORT (codex R6).

    `--dataset mecharm_redblock_box_teach_v1 --trim-mid-idle` のように入力と同じ名前を
    渡すと、お手本データそのものを詰めた版で上書きしてしまう (frames も作り直され、
    元の 10Hz の記録が復元できなくなる)。
    既に全エピソードが trim_mid_idle=true で作られているデータセットは、
    作り直し (--force) を通すため許可する。
    """
    metas = sorted((ds / "raw_episodes").glob("*/meta.json"))
    if not metas:
        return
    not_trimmed = [p.parent.name for p in metas
                   if json.loads(p.read_text()).get("trim_mid_idle") is not True]
    if not_trimmed:
        sys.exit(
            f"[ABORT] --trim-mid-idle の出力先が既存の非 trim データセットです: {ds}\n"
            f"        trim_mid_idle でないエピソード {len(not_trimmed)} 本 "
            f"(例: {', '.join(not_trimmed[:3])})\n"
            f"        元データを上書きしないよう、--dataset に新しい名前を指定してください。")


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--dataset", default=DEFAULT_DATASET)
    ap.add_argument("--since", default="20261015", help="run_stem の日付 (YYYYMMDD) 以降")
    ap.add_argument("--run", action="append", help="特定の run_stem だけ (複数可)")
    ap.add_argument("--include-failed", action="store_true", help="人の判定 no も含める (分析用)")
    ap.add_argument("--force", action="store_true", help="既存エピソードを作り直す")
    ap.add_argument("--trim-mid-idle", action="store_true",
                    help="途中の停止区間を先頭 %d ステップだけ残して詰める (既定: しない)"
                         % MID_IDLE_KEEP_STEPS)
    args = ap.parse_args()
    ensure_ssd()

    ds = DATA_ROOT / "datasets" / args.dataset
    if args.trim_mid_idle:
        assert_trim_target_is_new(ds)   # codex R6: 元データの上書きを防ぐ
    out_root = ds / "raw_episodes"
    out_root.mkdir(parents=True, exist_ok=True)
    runs = sorted(p for p in RUNS_ROOT.glob("run_*") if p.is_dir())
    if args.run:
        runs = [p for p in runs if p.name in set(args.run)]
    else:
        runs = [p for p in runs if p.name.split("_")[2] >= args.since]
        # LOG352 (codex R5 K3-a): top.mp4 が無い試行は対象から外すのが既定だが、
        # **recording_enabled=False を明示している試行だけは残す**。
        # こうしないと --no-record で走らせた試行が build_one に届かず、
        # index.json に no_recording の理由が残らない。
        runs = [p for p in runs
                if (p / "recording" / "top.mp4").exists()
                or _recording_disabled(p)]

    results = []
    for r in runs:
        try:
            res = build_one(r, out_root / r.name, args)
        except Exception as e:
            res = {"run": r.name, "used": False, "reason": f"exception:{type(e).__name__}:{e}"}
        results.append(res)
        flag = "OK " if res["used"] else "-- "
        print(f"[{flag}] {res['run']}  {res.get('steps', '')}  {res['reason']}")

    index_path = ds / "index.json"
    old = json.loads(index_path.read_text()) if index_path.exists() else {}
    for res in results:
        old[res["run"]] = res
    index_path.write_text(json.dumps(old, indent=2, ensure_ascii=False))
    used = [v for v in old.values() if v.get("used")]
    print(f"\n採用エピソード合計: {len(used)}  総ステップ: {sum(v.get('steps', 0) for v in used)}"
          f"  → {out_root}")


if __name__ == "__main__":
    main()
