Add remaining runningbench_handoff scripts (9) covering each layer per-layer repairs, plus 3 general early-era infra scripts

multi_video_cross_video_methodology/README.md

@@ -143,6 +143,35 @@ P03: 18段 · 同上                                    · Traj01/02/03
 **顺序值得记住**：`whole_video`先生成(每段录像自己的标注)，`cross_video`是**用多段`whole_video`标注拼出来的**——
 两层共用同一次"全局遍历"的产出，不是两条独立流水线。
 
+### 4.3 `04_脚本/` 目录里其余9个脚本——覆盖了每一层各自的短板
+
+`generate_cross_video_qa.py`和`build_fullvideo_annotations.py`只是这个目录的一部分。补全后能看出
+这条流水线其实是"哪层测出问题就专门写脚本修哪层"，不是一次性设计好的：
+
+- **`blind_test_segments.py`**——测出`segments_60s`真实盲猜率48.6%(不是官方宣称的17.6%, 那个数字只是
+  "选项字母分布均匀"，不是"题需要看视频")；**`repair_segment_distractors.py`**——照着测出来的问题重造干扰项，
+  就是`segments_60s_gemini_verification/`里`blind_gate_repair_20260906/`那批脚本的同一条思路，但这里是
+  更早的一版实现；**`export_segment_bundle.py`**——把修好的segment题打包成本地可跑闸门的自包含单元。
+- **`annotate_missing_hf_60s.py`**——补7段HuggingFace录像缺失的60秒粒度标注，缺失不是随机的：
+  同一场景的快/慢速版本都在，只有中间某个速度缺了60秒描述，像是标注批次中途断了没续上。
+- **`annotate_windows_from_video.py`**——推翻了第一版180秒窗口题的做法：直接用已有60秒caption拼凑出的
+  180秒标注写题，盲猜率68.4%，比它想改进的segment语料还差（复核本身没问题，3/76矛盾，纯粹是题目好猜）。
+  改成让模型**真正看完整个180秒窗口**再写标注，才有了`build_window_questions.py`这层的题。
+- **`build_window_questions.py`**——180秒窗口这层存在的理由：60秒只有一个阶段出不了转弯题，整段录像
+  10-33分钟又太长，180秒正好落在"结构开始出现"的区间（摘录实验测过：产出率从1分钟42%涨到4分钟60%）。
+- **`expand_mcq.py`**——纯文本扩充干扰项数量/每段题量，不解码不上传任何视频，读的是已有的`dense_annotations`。
+- **`package_full_release.py`** / **`package_gdrive_release.py`**——两种打包范围: 全量(含HuggingFace+VideoBench,
+  covers剩下9,925道未判定题里的5,324道) vs 仅Google Drive子集(只有这个来源才带`scene_id`/`route_id`/
+  `turnaround_sec`这类路线元数据，路线类题目就是靠这个校验的)。
+
+`cut_window_clips.py`（180秒窗口切片，见文件清单）也在这个目录，服务上面`build_window_questions.py`这条线。
+
+### 4.4 补充的通用早期脚本
+
+`pilot_scripts_20260824/`除了原来的4个Gemini试点脚本，还补了3个同期的通用基础设施：
+`build_manifest.py`（给CVHCI录像集建元数据清单）、`download_gdrive_ranges.py`（Google Drive大文件下载遇到
+限额页时按HTTP Range分片续传的兜底方案）、`make_contact_sheet.py`（从视频里等间隔抽帧拼联络表，人工核对用）。
+
 ---
 
 ## 5. 闸门是怎么做的（5步，顺序不可改）
@@ -213,11 +242,23 @@ source_docs/
   master_index_1526_reviewed.jsonl    1,526题人工复核集的权威索引(真实5种unit的数据来源, 见§2)
   录像清单.csv                        55条录像的完整元数据(participant/speed/lighting/route_id/shape/turnaround_sec等)
   cut_window_clips.py                 切180秒窗口用的脚本(480p, 服务whole_video/cross_video的time_index证据)
+  blind_test_segments.py              测出segments_60s真实盲猜率48.6%(见§4.3)
+  repair_segment_distractors.py       照测出的问题重造segments_60s干扰项(见§4.3)
+  export_segment_bundle.py            把修好的segment题打包成本地可跑闸门的自包含单元
+  annotate_missing_hf_60s.py          补7段HuggingFace录像缺失的60秒粒度标注
+  annotate_windows_from_video.py      让模型真正看完180秒窗口再写标注(取代盲猜率68.4%的第一版做法)
+  build_window_questions.py           180秒窗口这层的出题脚本(见§4.3, 为什么是180秒)
+  expand_mcq.py                       纯文本扩充干扰项数量/每段题量, 不碰视频
+  package_full_release.py             全量打包(含HuggingFace+VideoBench, 给全体未判定题的人工筛选用)
+  package_gdrive_release.py           仅Google Drive子集打包(唯一带route_id等路线元数据的来源)
   pilot_scripts_20260824/             全项目最早的Gemini视频标注试点(v1/v2的原型, 见§2.5)
     gemini_video_pilot.py               单次调用最小样例
     run_gemini_annotation_pilot.py      批量编排: 切片→调Gemini→组装成可复核JSONL
     apply_gemini_pilot_reviews.py       合并人工复核意见, 同时保留Gemini原始提案供审计
     make_video_clip.py                  更早的切片工具: 做隐私更安全、码率更低的试点用片段
+    build_manifest.py                   给CVHCI录像集建元数据清单
+    download_gdrive_ranges.py           Google Drive大文件下载遇限额时按HTTP Range续传的兜底方案
+    make_contact_sheet.py               从视频等间隔抽帧拼联络表, 人工核对用
 ```
 
 原始位置（conductor）：`s3://yuedong/cvhci_video_understanding/bundles/runningbench_handoff/`

multi_video_cross_video_methodology/source_docs/annotate_missing_hf_60s.py

@@ -0,0 +1,121 @@
+#!/usr/bin/env python3
+"""Cut and caption the seven HuggingFace recordings that never got a 60-second pass.
+
+The 60s layer covers 65 of the 72 HuggingFace recordings on disk. The seven left out are
+not random: kit_scc_hochhaus has both its fast and normal runs missing, sinzheim_city both
+its normal and slow -- while other speeds of the same scene were done. That pattern reads
+as a batch that died partway and was never resumed, not as unusable footage. They do have
+180s and whole-video descriptions, so the gap is specifically the fine granularity.
+
+Reuses annotate_60s() from repair_runningbench_annotations.py so these segments come out
+byte-compatible with the 1,342 that already exist -- same CAPTION_MODEL, same two-step
+caption then structure pass, same five-field schema. Reimplementing the prompt would give
+captions that read differently from every other row in the corpus.
+
+Two things that module hardcodes for Google Drive have to be corrected here:
+  - source_video_id is written as "google_drive/<participant>/<file>"; these are
+    huggingface, and mislabelling provenance is what made the earlier source census wrong.
+  - discover_sources() expects <root>/<participant>/<file>, but this footage nests one
+    level deeper (Alec/sinzheim_city/sinzheim_city_slow.MOV), so the sources are passed
+    in explicitly instead of discovered.
+
+Usage:  annotate_missing_hf_60s.py [--dry-run] [--only STEM]
+"""
+import argparse
+import importlib.util
+import json
+import os
+import sys
+import types
+from pathlib import Path
+
+BASE = Path("/mnt/task_runtime/bolt/gdrive_relay")
+HF_ROOT = Path("/mnt/data/cvhci_video_understanding/raw/huggingface")
+WORK = Path("/mnt/data/data_anno/runningbench_hf_gapfill")
+FFMPEG = Path("/mnt/data/data_anno/ffmpeg-7.0.2-amd64-static/ffmpeg")
+FFPROBE = Path("/mnt/data/data_anno/ffmpeg-7.0.2-amd64-static/ffprobe")
+
+# Explicit, because the layout nests deeper than discover_sources() expects.
+MISSING = [
+    "Markus/BLB-Euro_Fast_260518_200852.mp4",
+    "Markus/Kiesweg_Fast_260518_202851.mp4",
+    "Alec/kit_mensa_scc/kit_mensa_scc_slow.mov",
+    "Alec/kit_scc_hochhaus/kit_scc_hochhaus_fast.mov",
+    "Alec/kit_scc_hochhaus/kit_scc_hochhaus_normal.mov",
+    "Alec/sinzheim_city/sinzheim_city_normal.mov",
+    "Alec/sinzheim_city/sinzheim_city_slow.MOV",
+]
+
+
+def load(name, path):
+    spec = importlib.util.spec_from_file_location(name, path)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--dry-run", action="store_true")
+    ap.add_argument("--only", help="process just the recording whose stem matches")
+    a = ap.parse_args()
+
+    gen = load("gen", BASE / "repair_runningbench_annotations.py")
+
+    sources = []
+    for rel in MISSING:
+        p = HF_ROOT / rel
+        if not p.exists():
+            print(f"  !! missing on disk: {rel}", flush=True)
+            continue
+        if a.only and a.only not in p.stem:
+            continue
+        sources.append(p)
+
+    total_segments = 0
+    for p in sources:
+        secs = gen.duration(FFPROBE, p)
+        n = int(-(-secs // 60))
+        total_segments += n
+        print(f"  {p.stem:44s} {secs:7.1f}s -> {n:2d} segments", flush=True)
+    print(f"\n{len(sources)} recordings · {total_segments} segments", flush=True)
+    if a.dry_run:
+        return 0
+
+    # Correct the provenance string the reused module writes. Patching the module's own
+    # helper keeps annotate_60s() untouched, so its resume logic and schema stay intact.
+    original_write = gen.write_json
+
+    def write_json(path, payload):
+        src = payload.get("original_video_path") or ""
+        if "huggingface" in src:
+            rel = os.path.relpath(src, HF_ROOT)
+            payload["source_video_id"] = f"huggingface/{rel}"
+            payload["provenance"] = "huggingface"
+        return original_write(path, payload)
+
+    gen.write_json = write_json
+
+    api = gen.Floodgate(os.environ.get("FLOODGATE_PROJECT_TOKEN", ""))
+    args = types.SimpleNamespace(work=WORK, ffmpeg=FFMPEG, ffprobe=FFPROBE)
+    WORK.mkdir(parents=True, exist_ok=True)
+
+    for i, source in enumerate(sources, 1):
+        # The "participant" is only used to name output subdirectories; for this footage
+        # the top-level HuggingFace folder (Alec / Markus) is the meaningful grouping.
+        participant = os.path.relpath(source, HF_ROOT).split(os.sep)[0]
+        print(f"\nsource {i}/{len(sources)}: {participant}/{source.name}", flush=True)
+        try:
+            gen.annotate_60s(args, api, source, participant)
+        except Exception as exc:
+            print(f"  !! {type(exc).__name__}: {exc}", flush=True)
+
+    done = sorted(WORK.glob("annotations_60s/**/*.json"))
+    print(f"\n{len(done)} annotations -> {WORK}/annotations_60s")
+    ok = sum(1 for f in done if (json.loads(f.read_text()).get("dense_annotations")))
+    print(f"  with dense_annotations: {ok}/{len(done)}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

multi_video_cross_video_methodology/source_docs/annotate_windows_from_video.py

@@ -0,0 +1,518 @@
+#!/usr/bin/env python3
+"""Annotate the 180-second windows by WATCHING them, then build questions from that.
+
+Why this replaces the previous attempt. The first pass wrote questions from the existing
+180s annotations, which are aggregations of three 60s captions -- `derived_from` names
+them -- and the pilot came back at 68.4% blind-guessable (CI [57.3, 77.8]), worse than the
+segment corpus it was meant to improve on. The re-check gate was fine: only 3 of 76 were
+contradicted. The questions were simply easy to guess, and by question type the failure was
+total where it should have been strongest -- window-turn-sequence scored 0/19.
+
+Aggregation is what broke it. Merging three minute-long captions flattens exactly what a
+three-minute question needs: a pedestrian in a blue bucket hat becomes "a pedestrian", a
+specific turn at a specific marker becomes "the path curves". Generic ground truth can only
+produce generic options, and then "which option sounds most coherent" is a winning strategy
+without watching anything.
+
+So the annotation is made from the footage at the scale the questions are asked at. Two
+things carry over from the full-video pipeline, which reaches 7.3% blind on 8-option multi:
+
+  1. Its structural schema -- route_phases, turns, revisited_landmarks, environment_stages,
+     dynamic_events -- rather than the 60s pass's frame-level five fields. Order and
+     progression are what three minutes supports asking about.
+  2. A clock burned into the top-left corner, one frame per second, showing true recording
+     time. The model reads timestamps instead of estimating them; the full-video pass found
+     estimates drifting +240 s over a 448 s video, and a question about what happened first
+     is worthless if the annotation's own ordering is guesswork.
+
+Usage:
+  annotate_windows_from_video.py --clips-only            # re-cut with the clock, no API
+  annotate_windows_from_video.py --pilot 8               # annotate + questions + gates
+  annotate_windows_from_video.py --all --jobs 2
+"""
+import argparse
+import base64
+import collections
+import concurrent.futures
+import glob
+import hashlib
+import importlib.util
+import json
+import math
+import os
+import random
+import re
+import shutil
+import subprocess
+import sys
+import threading
+from pathlib import Path
+
+BASE = Path("/mnt/task_runtime/bolt/gdrive_relay")
+SRC = "/mnt/data/data_anno/runningbench_gap_repair/annotations_180s"
+OUT = Path("/mnt/data/data_anno/runningbench_windows_v2")
+CLIPS = OUT / "clips_clock_480p"
+FFMPEG = "/mnt/data/data_anno/ffmpeg-7.0.2-amd64-static/ffmpeg"
+INLINE_CAP = 11 * 1024 * 1024
+QUOTA_PER_SECOND = 0.45
+SEED = 20260831
+
+TYPES = ("window-event-order", "window-turn-sequence",
+         "window-environment-shift", "window-object-timing")
+
+LEAK = ("trial", "traj", ".mov", ".mp4", "filename", "annotation",
+        "described", "the description", "the evidence", "per the", "according to the")
+
+OUT_OF_SCENE = ("beach", "highway", "motorway", "forest", "woods", "indoor", "shopping mall",
+                "airport terminal", "subway", "train station", "stadium", "boardwalk",
+                "desert", "mountain trail", "swimming", "driving", "dashboard", "cockpit")
+
+ANNOTATE_PROMPT = """You are watching a {length}-second stretch of a first-person walking/running recording,
+anonymous id {vid}. The stretch covers {p0}-{p1} seconds of the full recording. Do not infer
+anything from a filename -- you have none.
+
+A clock in the TOP-LEFT corner shows the true recording time as MM:SS. READ every time you
+report from that clock and convert to seconds; never estimate time from pacing.
+
+Your job is the STRUCTURE of this stretch, in order, and the DISTINCTIVE detail that
+identifies each place. Both matter: order alone gives questions no grounding, and detail
+alone gives no order to ask about.
+
+Return one JSON object:
+{{
+ "route_phases": [ {{"start_sec": {p0}, "end_sec": 0, "description": "...",
+                     "landmarks": ["specific, identifying, not 'a building'"],
+                     "surface": "asphalt|gravel|paved|dirt|mixed", "setting": "..."}} ],
+ "turns": [ {{"time_sec": 0, "direction": "left|right|u-turn|straight-on",
+              "sharpness": "gentle|moderate|sharp", "evidence": "what marks it"}} ],
+ "revisited_landmarks": [ {{"landmark": "...", "first_sec": 0, "second_sec": 0,
+                            "direction_change": "same|opposite|unclear"}} ],
+ "environment_stages": ["how the surroundings progress, in order"],
+ "dynamic_events": [ {{"time_sec": 0, "description": "...",
+                       "kind": "person|vehicle|animal|obstacle|other"}} ],
+ "distinctive_objects": [ {{"object": "...", "attributes": ["colour", "material", "..."],
+                            "side": "left|right|ahead|overhead", "seen_sec": 0}} ],
+ "uncertainties": ["..."]
+}}
+
+Phases must tile {p0}-{p1} seconds in order: each end_sec equals the next start_sec, the
+first start_sec is {p0}, the last end_sec is {p1}.
+
+Name landmarks and objects specifically enough that someone could recognise this exact
+place -- "a red and white striped warning pole", not "a pole". Use only what is visible."""
+
+Q_PROMPT = """Write exactly {n} benchmark questions about ONE {length}-second stretch of a first-person
+walking/running video, anonymous id {vid}, covering {p0}-{p1} seconds of the recording.
+
+ANNOTATION (the only ground truth; it was written while watching this exact stretch):
+{annotation}
+
+Each question must need the WHOLE stretch. A question answerable from one frame, or from any
+single minute of it, does not belong here: ask about order, about change across the stretch,
+about what happened before or after what.
+
+Use these types, spread evenly: {types}
+  window-event-order        the sequence in which events occur across the stretch
+  window-turn-sequence      the trajectory: which turns, in which order, how sharp
+  window-environment-shift  how the surroundings change from the start to the end
+  window-object-timing      which objects appear in which part of the stretch
+
+FORMAT -- exactly 8 options, of which exactly 3 are correct. Return the three correct ones
+first; they get shuffled afterwards.
+
+THE FIVE WRONG OPTIONS ARE THE HARD PART. An earlier version of this task returned 68% of
+its questions answerable with no video at all, and every one of its turn-sequence questions
+failed. Read all of this.
+
+A wrong option must be wrong ONLY because the video says otherwise -- never because a reader
+can rule it out from the setting. Someone who knows this is a person on foot outdoors, and
+nothing else, must find all eight equally possible. So:
+
+- Build them from THIS stretch's own specifics: the landmarks, objects and turns the
+  annotation names. Use the identifying detail -- "the red and white striped pole", not
+  "a pole" -- in wrong options as much as in right ones. Generic wrong options next to
+  specific correct ones is the single clearest tell.
+- Make them wrong by COMPOSITION, not by content: the right things in the wrong order, an
+  event placed in the wrong phase, two landmarks swapped, a turn given the wrong direction
+  or the wrong sharpness, an object moved to the other side of the path.
+- Do NOT write each wrong option as a correct one with a single detail edited. If every
+  wrong option is one edit from a right one, then on each detail the correct value is the
+  majority value, and the answer can be recovered by taking the most common colour, count
+  or side -- no video needed. A set built that way once drove blind guessing from 48.6%
+  to 75%.
+- Vary which details differ and how many: change two or three at once, in different
+  combinations, so no option sits at the centre of the set.
+- Keep all eight the same length and specificity. The correct options must not be the
+  longest or the most detailed -- picking the longest option alone wins 42.2% of
+  single-answer questions in an earlier corpus.
+
+Every question carries evidence_spans in seconds of the FULL recording, inside {p0}-{p1}.
+
+Return only:
+{{"questions": [{{"question": "...", "question_type": "...",
+  "options": ["correct 1", "correct 2", "correct 3", "wrong 1", "wrong 2", "wrong 3", "wrong 4", "wrong 5"],
+  "evidence_spans": [{{"start_seconds": 0, "end_seconds": 0, "description": "..."}}],
+  "why_hard": "what a viewer must track across the stretch to answer"}}]}}"""
+
+RECHECK_PROMPT = """Verify one benchmark question against the clip, which is exactly the stretch the
+question is about.
+
+QUESTION: {question}
+OPTIONS: {options}
+MARKED CORRECT: {answer}
+
+Watch the clip. Decide whether the marked options -- all of them, and no others -- are the
+correct answer.
+
+- "supported"    the marked options are right and the unmarked ones are wrong
+- "contradicted" the clip shows something else; say what in notes
+- "insufficient" the clip does not settle it
+
+Judge only what the clip shows. If a detail is legible, it counts, whatever the encode.
+
+Return only: {{"verdict": "...", "correct_answer_if_different": null, "notes": "..."}}"""
+
+
+def wilson(k, n, z=1.96):
+    if not n:
+        return (0.0, 0.0)
+    p = k / n
+    d = 1 + z * z / n
+    c = p + z * z / (2 * n)
+    h = z * math.sqrt(p * (1 - p) / n + z * z / (4 * n * n))
+    return (100 * (c - h) / d, 100 * (c + h) / d)
+
+
+def load(name, path):
+    spec = importlib.util.spec_from_file_location(name, path)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+def clock_frames(tmpdir, start, length):
+    """One PNG per second showing true recording time, for overlay onto the clip."""
+    from PIL import Image, ImageDraw, ImageFont
+    tmpdir.mkdir(parents=True, exist_ok=True)
+    try:
+        font = ImageFont.load_default(size=26)
+    except TypeError:
+        font = ImageFont.load_default()
+    for k in range(int(length) + 2):
+        t = int(start) + k
+        img = Image.new("RGB", (118, 36), (0, 0, 0))
+        ImageDraw.Draw(img).text((8, 4), f"{t // 60:02d}:{t % 60:02d}", fill=(255, 255, 255), font=font)
+        img.save(tmpdir / f"tc_{k:05d}.png")
+    return tmpdir / "tc_%05d.png"
+
+
+def cut_with_clock(source, start, length, dst):
+    if dst.exists() and 4096 < dst.stat().st_size <= INLINE_CAP:
+        return "skip"
+    dst.parent.mkdir(parents=True, exist_ok=True)
+    tmp = dst.parent / f".tc_{dst.stem}"
+    try:
+        pattern = clock_frames(tmp, start, length)
+        budget = int(INLINE_CAP * 8 * 0.88 / max(length, 1) / 1000)
+        for h, kbps in ((480, budget), (432, int(budget * 0.97)), (360, int(budget * 0.95))):
+            r = subprocess.run(
+                [FFMPEG, "-y", "-ss", str(start), "-t", str(length), "-i", str(source),
+                 "-framerate", "1", "-i", str(pattern),
+                 "-filter_complex", f"[0:v]scale=-2:{h}[v];[v][1:v]overlay=6:6:shortest=1",
+                 "-c:v", "libx264", "-preset", "veryfast", "-b:v", f"{kbps}k",
+                 "-maxrate", f"{int(kbps * 1.15)}k", "-bufsize", f"{kbps * 2}k",
+                 "-an", "-movflags", "+faststart", str(dst)],
+                stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            if r.returncode == 0 and dst.exists() and dst.stat().st_size <= INLINE_CAP:
+                return "ok"
+        return "oversize"
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+
+
+def video_part(path):
+    data = Path(path).read_bytes()
+    if len(data) > INLINE_CAP:
+        raise ValueError(f"clip is {len(data)/2**20:.1f} MiB, over the inline cap")
+    return {"inlineData": {"mimeType": "video/mp4", "data": base64.b64encode(data).decode("ascii")}}
+
+
+def validate_annotation(d, p0, p1):
+    ph = d.get("route_phases")
+    if not isinstance(ph, list) or not ph:
+        raise ValueError("route_phases required")
+    prev = None
+    for p in ph:
+        a, b = float(p["start_sec"]), float(p["end_sec"])
+        if not (p0 - 2 <= a < b <= p1 + 2):
+            raise ValueError(f"phase {a}-{b} outside window {p0}-{p1}")
+        if prev is not None and abs(a - prev) > 2:
+            raise ValueError(f"phases must tile: gap at {prev} -> {a}")
+        prev = b
+        if not p.get("landmarks"):
+            raise ValueError("each phase needs landmarks")
+    for k in ("turns", "revisited_landmarks", "environment_stages",
+              "dynamic_events", "distinctive_objects"):
+        if not isinstance(d.get(k), list):
+            raise ValueError(f"{k} must be a list")
+
+
+def make_q_validator(n, p0, p1):
+    def check(d):
+        qs = d.get("questions")
+        if not isinstance(qs, list) or len(qs) != n:
+            raise ValueError(f"need exactly {n} questions, got {len(qs) if isinstance(qs, list) else '?'}")
+        for q in qs:
+            stem = (q.get("question") or "").strip()
+            if not stem:
+                raise ValueError("empty question")
+            low = stem.lower()
+            for bad in LEAK:
+                if bad in low:
+                    raise ValueError(f"question leaks {bad!r}: {stem[:60]}")
+            if q.get("question_type") not in TYPES:
+                raise ValueError(f"bad question_type {q.get('question_type')!r}")
+            opts = q.get("options")
+            if not isinstance(opts, list) or len(opts) != 8:
+                raise ValueError(f"need exactly 8 options, got {len(opts) if isinstance(opts, list) else '?'}")
+            seen = set()
+            for o in opts:
+                if not isinstance(o, str) or not o.strip():
+                    raise ValueError("options must be non-empty strings")
+                if "\n" in o:
+                    raise ValueError("one option per string; this one contains a newline")
+                key = o.strip().lower()
+                if key in seen:
+                    raise ValueError(f"duplicate option: {o[:40]!r}")
+                seen.add(key)
+                for bad in OUT_OF_SCENE:
+                    if bad in key:
+                        raise ValueError(f"option names out-of-scene {bad!r}: {o[:50]}")
+            lengths = [len(o) for o in opts]
+            if sorted(range(8), key=lambda i: -lengths[i])[:3] == [0, 1, 2]:
+                raise ValueError("the three correct options are the three longest")
+            spans = q.get("evidence_spans")
+            if not isinstance(spans, list) or not spans:
+                raise ValueError("evidence_spans required")
+            for s in spans:
+                a, b = s.get("start_seconds"), s.get("end_seconds")
+                if not isinstance(a, (int, float)) or not isinstance(b, (int, float)) or b <= a:
+                    raise ValueError(f"bad span {s}")
+                if b < p0 - 5 or a > p1 + 5:
+                    raise ValueError(f"span {a}-{b} outside window {p0}-{p1}")
+    return check
+
+
+def validate_verdict(d):
+    if d.get("verdict") not in ("supported", "contradicted", "insufficient"):
+        raise ValueError(f"bad verdict {d.get('verdict')!r}")
+
+
+def shuffle(q):
+    texts = q["options"]
+    correct = set(range(3))
+    order = list(range(len(texts)))
+    random.Random(hashlib.sha256(q["question"].encode("utf-8")).hexdigest()).shuffle(order)
+    q["options"] = {chr(ord("A") + i): texts[s] for i, s in enumerate(order)}
+    q["answer"] = sorted(chr(ord("A") + i) for i, s in enumerate(order) if s in correct)
+    q["option_order"] = "shuffled"
+
+
+def collect():
+    rows = []
+    for path in sorted(glob.glob(f"{SRC}/**/*.json", recursive=True)):
+        rec = json.load(open(path))
+        source = rec.get("original_video_path") or ""
+        if not source or not os.path.exists(source):
+            continue
+        stem = os.path.basename(source).rsplit(".", 1)[0]
+        idx = int(rec.get("chunk_index", 0))
+        p0 = float(rec["start_time_sec"])
+        p1 = float(rec["end_time_sec"])
+        rows.append({"video": stem, "chunk": idx, "source": source, "p0": p0, "p1": p1,
+                     "clip": CLIPS / stem / f"{stem}_w{idx}.clock.mp4"})
+    return rows
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--clips-only", action="store_true")
+    ap.add_argument("--pilot", type=int, default=0)
+    ap.add_argument("--all", action="store_true")
+    ap.add_argument("--n-per-window", type=int, default=4)
+    ap.add_argument("--jobs", type=int, default=2)
+    ap.add_argument("--out", default=str(OUT / "questions.json"))
+    a = ap.parse_args()
+
+    rows = collect()
+    print(f"{len(rows)} windows from {len({r['video'] for r in rows})} recordings", flush=True)
+
+    if a.clips_only:
+        tally = collections.Counter()
+        with concurrent.futures.ThreadPoolExecutor(max_workers=6) as pool:
+            futs = {pool.submit(cut_with_clock, r["source"], r["p0"], r["p1"] - r["p0"], r["clip"]): r
+                    for r in rows}
+            for i, f in enumerate(concurrent.futures.as_completed(futs), 1):
+                tally[f.result()] += 1
+                if i % 20 == 0 or i == len(rows):
+                    size = sum(p.stat().st_size for p in CLIPS.rglob("*.mp4")) / 2**30
+                    print(f"  {i}/{len(rows)} {dict(tally)} {size:.2f} GiB", flush=True)
+        print(f"done: {dict(tally)} -> {CLIPS}")
+        return 0
+
+    if not (a.pilot or a.all):
+        ap.error("pass --clips-only, --pilot N, or --all")
+
+    rows = [r for r in rows if r["clip"].exists()]
+    print(f"{len(rows)} windows have a clock clip", flush=True)
+    if a.pilot:
+        rng = random.Random(SEED)
+        by_video = collections.defaultdict(list)
+        for r in rows:
+            by_video[r["video"]].append(r)
+        picked = []
+        for v in sorted(by_video):
+            g = by_video[v]
+            rng.shuffle(g)
+            picked.append(g[0])
+        rng.shuffle(picked)
+        rows = picked[:a.pilot]
+        print(f"pilot: {len(rows)} windows", flush=True)
+
+    fv = load("fv", BASE / "build_fullvideo_annotations.py")
+    gen = load("gen", BASE / "repair_runningbench_annotations.py")
+    api = gen.Floodgate("")
+    api.session = fv.PacedSession(api.session, fv.RateLimiter(QUOTA_PER_SECOND))
+    OUT.mkdir(parents=True, exist_ok=True)
+
+    questions = []
+    done = set()
+    if os.path.exists(a.out):
+        try:
+            prev = json.load(open(a.out))
+            questions = prev.get("questions", [])
+            done = {(q["video"], q["chunk"]) for q in questions}
+            print(f"resuming: {len(questions)} questions over {len(done)} windows", flush=True)
+        except Exception:
+            pass
+    rows = [r for r in rows if (r["video"], r["chunk"]) not in done]
+    print(f"to do: {len(rows)}", flush=True)
+
+    lock = threading.Lock()
+    counter = {"n": 0}
+
+    def work(r):
+        length = r["p1"] - r["p0"]
+        try:
+            parts = [{"text": ANNOTATE_PROMPT.format(length=int(length), vid=r["video"],
+                                                     p0=int(r["p0"]), p1=int(r["p1"]))},
+                     video_part(r["clip"])]
+            ann = gen.clean_json(api.generate(gen.CAPTION_MODEL, parts, 16384, json_mode=True))
+            validate_annotation(ann, r["p0"], r["p1"])
+        except Exception as exc:
+            return [], None, f"annotate: {type(exc).__name__}: {exc}"
+
+        try:
+            data = gen.generate_valid_json(
+                api,
+                Q_PROMPT.format(n=a.n_per_window, length=int(length), vid=r["video"],
+                                p0=int(r["p0"]), p1=int(r["p1"]),
+                                annotation=json.dumps(ann, ensure_ascii=False),
+                                types=", ".join(TYPES)),
+                make_q_validator(a.n_per_window, r["p0"], r["p1"]), 32768)
+        except Exception as exc:
+            return [], ann, f"questions: {type(exc).__name__}: {exc}"
+
+        out = []
+        for q in data["questions"]:
+            shuffle(q)
+            q.update({"video": r["video"], "chunk": r["chunk"],
+                      "window_sec": [r["p0"], r["p1"]], "clip": str(r["clip"])})
+            gates = {"structure": "pass", "leak_scan": "pass"}
+            arity = "Exactly three options are correct."
+            hits, guesses = 0, []
+            for t in range(3):
+                try:
+                    bg = gen.generate_valid_json(
+                        api, fv.BLIND_PROMPT.format(question=q["question"],
+                                                   options=json.dumps(q["options"], ensure_ascii=False),
+                                                   arity=f"{arity} (attempt {t+1})"),
+                        fv.validate_blind, 4096)
+                    g = sorted(bg["answer"])
+                except Exception:
+                    g = ["?"]
+                guesses.append(g)
+                hits += g == sorted(q["answer"])
+            gates["blind_guess"] = {"guesses": guesses, "hits_of_3": hits, "matches_gold": hits >= 2}
+            if gates["blind_guess"]["matches_gold"]:
+                gates["visual_recheck"] = {"verdict": "skipped", "notes": "blind-guessable"}
+            else:
+                try:
+                    parts = [{"text": RECHECK_PROMPT.format(
+                                  question=q["question"],
+                                  options=json.dumps(q["options"], ensure_ascii=False),
+                                  answer=json.dumps(q["answer"]))},
+                             video_part(r["clip"])]
+                    gates["visual_recheck"] = gen.clean_json(
+                        api.generate(gen.CAPTION_MODEL, parts, 8192, json_mode=True))
+                    validate_verdict(gates["visual_recheck"])
+                except Exception as exc:
+                    gates["visual_recheck"] = {"verdict": "error", "notes": type(exc).__name__}
+            q["gates"] = gates
+            out.append(q)
+        return out, ann, None
+
+    anns = {}
+    with concurrent.futures.ThreadPoolExecutor(max_workers=a.jobs) as pool:
+        for got, ann, err in pool.map(work, rows):
+            with lock:
+                counter["n"] += 1
+                i = counter["n"]
+                if err:
+                    print(f"  !! window {i}: {err}", flush=True)
+                if ann:
+                    anns[i] = ann
+                questions += got
+                usable = sum(1 for q in questions
+                             if q["gates"].get("visual_recheck", {}).get("verdict") == "supported"
+                             and not q["gates"]["blind_guess"].get("matches_gold"))
+                blind = sum(1 for q in questions if q["gates"]["blind_guess"].get("matches_gold"))
+                print(f"  {i}/{len(rows)} · {len(questions)} q · {usable} usable · {blind} blind",
+                      flush=True)
+                json.dump({"n": len(questions), "questions": questions},
+                          open(a.out, "w"), ensure_ascii=False, indent=1)
+
+    total = len(questions)
+    if not total:
+        print("no questions produced")
+        return 1
+    usable = [q for q in questions
+              if q["gates"].get("visual_recheck", {}).get("verdict") == "supported"
+              and not q["gates"]["blind_guess"].get("matches_gold")]
+    blind = sum(1 for q in questions if q["gates"]["blind_guess"].get("matches_gold"))
+    lo, hi = wilson(len(usable), total)
+    bl, bh = wilson(blind, total)
+    print(f"\n=== {total} questions -> {a.out}")
+    print(f"usable        {len(usable)}/{total} = {100*len(usable)/total:.1f}%  95% CI [{lo:.1f}, {hi:.1f}]")
+    print(f"blind-guessed {blind}/{total} = {100*blind/total:.1f}%  95% CI [{bl:.1f}, {bh:.1f}]")
+    print(f"  aggregated-annotation attempt: 68.4% blind [57.3, 77.8]")
+    print(f"  segment corpus 48.6% · full-video 8-option multi 7.3%")
+    v = collections.Counter()
+    for q in questions:
+        rc = q["gates"].get("visual_recheck", {})
+        v[rc.get("verdict") if isinstance(rc, dict) else rc] += 1
+    print(f"recheck       {dict(v)}")
+    by_t = collections.defaultdict(collections.Counter)
+    for q in questions:
+        by_t[q["question_type"]]["ok" if q in usable else "no"] += 1
+    for t, c in sorted(by_t.items()):
+        n = c["ok"] + c["no"]
+        print(f"  {t:26s} {c['ok']:3d}/{n:3d}  {100*c['ok']/n:3.0f}%   (aggregated: "
+              f"{'0%' if t == 'window-turn-sequence' else '11-63%'})")
+    if total < 100:
+        print(f"\nNOTE: n={total}. Read the intervals, not the point estimates.")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

multi_video_cross_video_methodology/source_docs/blind_test_segments.py

@@ -0,0 +1,140 @@
+#!/usr/bin/env python3
+"""Measure how guessable the 60-second segment questions actually are.
+
+The segment corpus has never faced a blind model. Its published "17.6% blind
+baseline" is only the answer-letter distribution -- it shows the shuffle removed
+positional bias, not that the questions need the video. The full-video corpus,
+which does run this test, found 6-option single-choice questions hit 41% blind:
+2.5x the 16.7% random baseline, and the leak is semantic, not positional.
+
+So this runs the identical procedure the full-video gates use -- same prompt,
+same three-vote rule, guessable at >=2/3 -- over a stratified sample, and reports
+a Wilson interval.
+
+Usage:  blind_test_segments.py [--n 800] [--out report.json]
+"""
+import argparse
+import collections
+import glob
+import importlib.util
+import json
+import math
+import random
+import sys
+from pathlib import Path
+
+SEG_ROOT = "/mnt/data/data_anno/runningbench_qa_expansion/annotations_60s"
+BASE = Path("/mnt/task_runtime/bolt/gdrive_relay")
+QUOTA_PER_SECOND = 0.45
+SEED = 20260830
+
+
+def load(name, path):
+    spec = importlib.util.spec_from_file_location(name, path)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+def wilson(k, n, z=1.96):
+    if not n:
+        return (0.0, 0.0)
+    p = k / n
+    d = 1 + z * z / n
+    c = p + z * z / (2 * n)
+    h = z * math.sqrt(p * (1 - p) / n + z * z / (4 * n * n))
+    return ((c - h) / d, (c + h) / d)
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--n", type=int, default=800)
+    ap.add_argument("--out", default="/mnt/data/data_anno/runningbench_qa_expansion/blind_test.json")
+    a = ap.parse_args()
+
+    fv = load("fv", BASE / "build_fullvideo_annotations.py")
+    gen = fv.load_generator()
+
+    pool = []
+    for path in sorted(glob.glob(f"{SEG_ROOT}/**/*.json", recursive=True)):
+        try:
+            record = json.load(open(path))
+        except Exception:
+            continue
+        for item in record.get("qa_pairs") or []:
+            opts, ans = item.get("options"), item.get("answer")
+            if not isinstance(opts, dict) or not opts or not isinstance(ans, list) or not ans:
+                continue
+            pool.append({"question": item["question"], "options": opts, "answer": sorted(ans),
+                         "type": item.get("type"), "n_opt": len(opts), "n_ans": len(ans),
+                         "file": path})
+    print(f"pool: {len(pool)} objective questions", flush=True)
+
+    # Stratify by (option count, single/multi) so the sample mirrors the corpus.
+    strata = collections.defaultdict(list)
+    for q in pool:
+        strata[(q["n_opt"], q["n_ans"] > 1)].append(q)
+    rng = random.Random(SEED)
+    sample = []
+    for key, group in sorted(strata.items()):
+        take = max(1, round(a.n * len(group) / len(pool)))
+        rng.shuffle(group)
+        sample += group[:take]
+    rng.shuffle(sample)
+    print(f"sample: {len(sample)} over {len(strata)} strata", flush=True)
+
+    api = gen.Floodgate("")
+    api.session = fv.PacedSession(api.session, fv.RateLimiter(QUOTA_PER_SECOND))
+
+    results = []
+    for i, q in enumerate(sample, 1):
+        arity = ("Exactly one option is correct." if q["n_ans"] == 1
+                 else "More than one option is correct.")
+        guesses, hits = [], 0
+        for attempt in range(3):
+            try:
+                raw = gen.generate_valid_json(
+                    api,
+                    fv.BLIND_PROMPT.format(question=q["question"],
+                                           options=json.dumps(q["options"], ensure_ascii=False),
+                                           arity=f"{arity} (attempt {attempt + 1})"),
+                    fv.validate_blind, 4096)
+                g = sorted(raw["answer"])
+            except Exception as exc:
+                g = [f"ERROR:{type(exc).__name__}"]
+            guesses.append(g)
+            hits += g == q["answer"]
+        results.append({**{k: q[k] for k in ("question", "type", "n_opt", "n_ans", "answer")},
+                        "guesses": guesses, "hits_of_3": hits, "guessable": hits >= 2})
+        if i % 25 == 0 or i == len(sample):
+            g = sum(1 for r in results if r["guessable"])
+            print(f"  {i}/{len(sample)}  guessable {g} ({100 * g / i:.1f}%)", flush=True)
+        json.dump({"n": len(results), "results": results}, open(a.out, "w"), ensure_ascii=False)
+
+    # ---- report -----------------------------------------------------------
+    def rate(rows):
+        if not rows:
+            return None
+        k = sum(1 for r in rows if r["guessable"])
+        lo, hi = wilson(k, len(rows))
+        return k, len(rows), 100 * k / len(rows), 100 * lo, 100 * hi
+
+    print("\n=== blind-guess rate (>=2 of 3 votes match) ===")
+    k, n, p, lo, hi = rate(results)
+    print(f"overall           {k}/{n} = {p:.1f}%   95% CI [{lo:.1f}, {hi:.1f}]")
+    for key, label in (((6, False), "6-option single"), ((8, True), "8-option multi")):
+        rows = [r for r in results if (r["n_opt"], r["n_ans"] > 1) == key]
+        if rows:
+            k, n, p, lo, hi = rate(rows)
+            rand = 100 / math.comb(key[0], rows[0]["n_ans"]) if key[1] else 100 / key[0]
+            print(f"{label:18s}{k}/{n} = {p:.1f}%   95% CI [{lo:.1f}, {hi:.1f}]   random ~{rand:.1f}%")
+    print("\nby question type:")
+    for t in sorted({r["type"] for r in results}):
+        rows = [r for r in results if r["type"] == t]
+        k, n, p, lo, hi = rate(rows)
+        print(f"  {str(t):30s} {k:3d}/{n:3d} = {p:5.1f}%   [{lo:.1f}, {hi:.1f}]")
+    print(f"\nwrote {a.out}")
+
+
+if __name__ == "__main__":
+    sys.exit(main())

multi_video_cross_video_methodology/source_docs/build_window_questions.py

@@ -0,0 +1,427 @@
+#!/usr/bin/env python3
+"""Benchmark questions from the 180-second window annotations.
+
+Why this layer. The 60s segments hold one phase and no turn, so the only questions they
+support are "what is in the frame" -- a blind model beats 48.6% of them. Whole videos
+support route questions but run 10-33 minutes. The 180s windows sit where structure
+starts: the excerpt study measured yield rising from 42% at 1 minute to 60% at 4, and
+three minutes is inside that band. Each window already carries a description of its own
+trajectory, turns and environment shifts, so the expensive viewing pass is already paid
+for; only the questions and the gates cost quota.
+
+What this layer is NOT. These annotations are aggregations of three 60s captions --
+their `derived_from` field names them -- not independent viewings. Every question written
+from them inherits whatever the 60s pass got wrong, which is exactly what the 480p
+re-check gate exists to catch. Treat an ungated question from here as unverified.
+
+Format. Eight options, three correct. Measured, not assumed: on the segment corpus a
+blind model scores 64.7% against single-answer questions and 25.3% against multi-answer
+ones, and on the full-video corpus 8-option multi runs 7.3%. Single-answer questions
+leak two ways at once -- picking the longest option alone wins 42.2% of them -- and
+repairing one leak leaves the other, so the format is chosen up front rather than fixed
+later.
+
+Gates, in this order:
+
+  1. shuffle        deterministic, seeded on the question text
+  2. structure      arity, distinct options, no empty text
+  3. leak scan      filename/speed/"per the description" blacklist
+  4. blind guess x3 answer with no video; >=2 hits of 3 drops the question
+  5. visual recheck 480p clip of that exact window; only "supported" survives
+
+Order is not arbitrary. Shuffling must precede the blind test: generators favour putting
+the answer first and blind models favour picking first, and testing before the shuffle
+once produced a 56.6% guess rate that was an artifact of position, not leakage. The blind
+test must precede the re-check because a question that fails it needs no video call --
+the most expensive step in the pipeline.
+
+Usage:
+  build_window_questions.py --pilot 20        # 20 windows, full gates, reports CIs
+  build_window_questions.py --all --jobs 2
+"""
+import argparse
+import base64
+import collections
+import concurrent.futures
+import glob
+import hashlib
+import importlib.util
+import json
+import math
+import os
+import random
+import re
+import sys
+import threading
+from pathlib import Path
+
+BASE = Path("/mnt/task_runtime/bolt/gdrive_relay")
+SRC = "/mnt/data/data_anno/runningbench_gap_repair/annotations_180s"
+CLIPS = Path("/mnt/data/data_anno/runningbench_windows/clips_480p")
+OUT = Path("/mnt/data/data_anno/runningbench_windows")
+QUOTA_PER_SECOND = 0.45
+SEED = 20260831
+
+TYPES = ("window-event-order", "window-turn-sequence",
+         "window-environment-shift", "window-object-timing")
+
+# Words that would let a reader answer from the question text or from artifacts of how
+# the corpus was built, rather than from the video.
+# Kept deliberately narrow. These are corpus artifacts -- filename fragments, and phrases
+# that point at the written annotation instead of the footage. Words that merely describe
+# what is on screen do not belong here: an earlier version blacklisted "segment", which
+# rejected the entirely fair phrasing "the video segment from 06:00 to 09:00" and burned a
+# retry on every occurrence. A leak filter that fights natural English costs quota and
+# teaches the generator nothing.
+LEAK = ("trial", "traj", ".mov", ".mp4", "filename", "annotation",
+        "described", "the description", "the evidence", "per the", "according to the")
+
+# Scenery this corpus does not contain. A distractor naming one of these is not a
+# distractor -- anyone who knows the setting drops it without watching. This list is the
+# defence the segment corpus never had, and its absence is why options there offered
+# engine noise and dashboard views for a question about someone running.
+OUT_OF_SCENE = ("beach", "highway", "motorway", "forest", "woods", "indoor", "shopping mall",
+                "airport terminal", "subway", "train station", "stadium", "boardwalk",
+                "desert", "mountain trail", "swimming", "driving", "dashboard", "cockpit")
+
+Q_PROMPT = """Write exactly {n} benchmark questions about ONE 180-second stretch of a first-person
+walking/running video, anonymous id {vid}. The stretch runs from {t0} to {t1} of that recording.
+
+EVIDENCE — everything known about this stretch:
+{evidence}
+
+Each question must need the WHOLE three minutes. A question answerable from any single
+frame, or from any one minute of it, does not belong here: ask about order, about change
+across the stretch, about what happened before or after what.
+
+Use these types, spread evenly: {types}
+  window-event-order        the sequence in which events occur across the stretch
+  window-turn-sequence      the trajectory: which turns, in which order, how sharp
+  window-environment-shift  how the surroundings change from the start to the end
+  window-object-timing      which objects appear in which part of the stretch
+
+FORMAT — exactly 8 options, of which exactly 3 are correct. Return the three correct ones
+first; they get shuffled afterwards.
+
+THE FIVE WRONG OPTIONS ARE THE HARD PART. Read all of this.
+
+A wrong option must be wrong ONLY because the video says otherwise — never because a
+reader can rule it out from the setting. Someone who knows this is a person on foot
+outdoors, and nothing else, must find all eight equally possible. So:
+
+- Build them from THIS stretch's own vocabulary: its objects, its paths, its turns. A
+  wrong option that names something absent from the evidence — a beach, a dashboard, an
+  indoor hall — is worthless.
+- Make them wrong by COMPOSITION, not by content: the right things in the wrong order,
+  an event placed in the wrong third, two objects swapped, a turn given the wrong
+  direction or the wrong sharpness.
+- Do NOT write each wrong option as a correct one with a single detail edited. If every
+  wrong option is one edit from a right one, then on each detail the correct value is
+  the majority value, and the whole answer can be recovered by taking the most common
+  colour, the most common count, the most common side — no video needed. This is the
+  single most common way a question set leaks; a set built that way once drove blind
+  guessing from 48.6% to 75%.
+- Vary which details differ and how many: change two or three at once, in different
+  combinations, so no option sits at the centre of the set.
+- Keep all eight the same length and the same specificity. The correct options must not
+  be the longest or the most detailed — picking the longest option alone wins 42.2% of
+  single-answer questions in an earlier corpus, and the same habit leaks here.
+
+Every question must also carry evidence_spans: the seconds within the FULL recording
+(not within this stretch) that show the answer, so the claim can be re-checked.
+
+Return only:
+{{"questions": [{{"question": "...", "question_type": "...",
+  "options": ["correct 1", "correct 2", "correct 3", "wrong 1", "wrong 2", "wrong 3", "wrong 4", "wrong 5"],
+  "evidence_spans": [{{"start_seconds": 0, "end_seconds": 0, "description": "..."}}],
+  "why_hard": "what a viewer must track across the three minutes to answer"}}]}}"""
+
+RECHECK_PROMPT = """Verify one benchmark question against the clip, which is exactly the stretch the
+question is about.
+
+QUESTION: {question}
+OPTIONS: {options}
+MARKED CORRECT: {answer}
+
+Watch the clip. Decide whether the marked options — all of them, and no others — are the
+correct answer.
+
+- "supported"    the marked options are right and the unmarked ones are wrong
+- "contradicted" the clip shows something else; say what in notes
+- "insufficient" the clip does not settle it
+
+Judge only what the clip shows. If a detail is legible, it counts, whatever the encode.
+
+Return only: {{"verdict": "...", "correct_answer_if_different": null, "notes": "..."}}"""
+
+
+def wilson(k, n, z=1.96):
+    if not n:
+        return (0.0, 0.0)
+    p = k / n
+    d = 1 + z * z / n
+    c = p + z * z / (2 * n)
+    h = z * math.sqrt(p * (1 - p) / n + z * z / (4 * n * n))
+    return (100 * (c - h) / d, 100 * (c + h) / d)
+
+
+INLINE_CAP = 11 * 1024 * 1024
+
+
+def video_part(path):
+    """Inline one clip. The API rejects a request whose inline payload exceeds 11 MiB."""
+    data = Path(path).read_bytes()
+    if len(data) > INLINE_CAP:
+        raise ValueError(f"clip is {len(data)/2**20:.1f} MiB, over the {INLINE_CAP/2**20:.0f} MiB inline cap")
+    return {"inlineData": {"mimeType": "video/mp4", "data": base64.b64encode(data).decode("ascii")}}
+
+
+def load(name, path):
+    spec = importlib.util.spec_from_file_location(name, path)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+def mmss(sec):
+    return f"{int(sec) // 60:02d}:{int(sec) % 60:02d}"
+
+
+def scene_vocabulary(evidence):
+    return set(re.findall(r"[a-z]{4,}", json.dumps(evidence, ensure_ascii=False).lower()))
+
+
+def make_validator(n, t0, t1, vocab):
+    def check(d):
+        qs = d.get("questions")
+        if not isinstance(qs, list) or len(qs) != n:
+            raise ValueError(f"need exactly {n} questions, got {len(qs) if isinstance(qs, list) else '?'}")
+        for q in qs:
+            stem = (q.get("question") or "").strip()
+            if not stem:
+                raise ValueError("empty question")
+            low = stem.lower()
+            for bad in LEAK:
+                if bad in low:
+                    raise ValueError(f"question leaks {bad!r}: {stem[:60]}")
+            if q.get("question_type") not in TYPES:
+                raise ValueError(f"bad question_type {q.get('question_type')!r}")
+            opts = q.get("options")
+            if not isinstance(opts, list) or len(opts) != 8:
+                raise ValueError(f"need exactly 8 options, got {len(opts) if isinstance(opts, list) else '?'}")
+            seen = set()
+            for o in opts:
+                if not isinstance(o, str) or not o.strip():
+                    raise ValueError("options must be non-empty strings")
+                if "\n" in o:
+                    raise ValueError("one option per string; this one contains a newline")
+                key = o.strip().lower()
+                if key in seen:
+                    raise ValueError(f"duplicate option: {o[:40]!r}")
+                seen.add(key)
+                for bad in OUT_OF_SCENE:
+                    if bad in key:
+                        raise ValueError(f"option names out-of-scene {bad!r}: {o[:50]}")
+            # The correct three are returned first; they must not be the longest three.
+            lengths = [len(o) for o in opts]
+            if sorted(range(8), key=lambda i: -lengths[i])[:3] == [0, 1, 2]:
+                raise ValueError("the three correct options are the three longest")
+            spans = q.get("evidence_spans")
+            if not isinstance(spans, list) or not spans:
+                raise ValueError("evidence_spans required")
+            for s in spans:
+                a, b = s.get("start_seconds"), s.get("end_seconds")
+                if not isinstance(a, (int, float)) or not isinstance(b, (int, float)) or b <= a:
+                    raise ValueError(f"bad span {s}")
+                if b < t0 - 5 or a > t1 + 5:
+                    raise ValueError(f"span {a}-{b} outside window {t0}-{t1}")
+    return check
+
+
+def validate_verdict(d):
+    if d.get("verdict") not in ("supported", "contradicted", "insufficient"):
+        raise ValueError(f"bad verdict {d.get('verdict')!r}")
+
+
+def shuffle(q):
+    texts = q["options"]
+    correct = set(range(3))                      # generator returns the correct three first
+    order = list(range(len(texts)))
+    random.Random(hashlib.sha256(q["question"].encode("utf-8")).hexdigest()).shuffle(order)
+    q["options"] = {chr(ord("A") + i): texts[src] for i, src in enumerate(order)}
+    q["answer"] = sorted(chr(ord("A") + i) for i, src in enumerate(order) if src in correct)
+    q["option_order"] = "shuffled"
+
+
+def collect():
+    rows = []
+    for path in sorted(glob.glob(f"{SRC}/**/*.json", recursive=True)):
+        rec = json.load(open(path))
+        source = rec.get("original_video_path") or ""
+        stem = os.path.basename(source).rsplit(".", 1)[0]
+        idx = int(rec.get("chunk_index", 0))
+        clip = CLIPS / stem / f"{stem}_w{idx}.480p.mp4"
+        rows.append({"file": path, "video": stem, "chunk": idx,
+                     "t0": float(rec["start_time_sec"]), "t1": float(rec["end_time_sec"]),
+                     "evidence": rec.get("dense_annotations"),
+                     "open_qa": rec.get("qa_pairs") or [],
+                     "clip": str(clip) if clip.exists() else None})
+    return rows
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--pilot", type=int, default=0, help="how many windows to run")
+    ap.add_argument("--all", action="store_true")
+    ap.add_argument("--n-per-window", type=int, default=4)
+    # The distractor repair is usually holding most of the 0.45 req/s quota; two workers
+    # here share it rather than starving both runs into 429 backoff.
+    ap.add_argument("--jobs", type=int, default=2)
+    ap.add_argument("--out", default=str(OUT / "questions.json"))
+    a = ap.parse_args()
+    if not (a.pilot or a.all):
+        ap.error("pass --pilot N or --all")
+
+    fv = load("fv", BASE / "build_fullvideo_annotations.py")
+    gen = load("gen", BASE / "repair_runningbench_annotations.py")
+
+    rows = collect()
+    print(f"{len(rows)} windows; {sum(1 for r in rows if r['clip'])} have a 480p clip", flush=True)
+    if a.pilot:
+        rng = random.Random(SEED)
+        by_video = collections.defaultdict(list)
+        for r in rows:
+            by_video[r["video"]].append(r)
+        picked = []
+        for vid in sorted(by_video):
+            group = by_video[vid]
+            rng.shuffle(group)
+            picked += group[:max(1, round(a.pilot / len(by_video)))]
+        rng.shuffle(picked)
+        rows = picked[:a.pilot]
+        print(f"pilot: {len(rows)} windows from {len({r['video'] for r in rows})} videos", flush=True)
+
+    api = gen.Floodgate("")
+    api.session = fv.PacedSession(api.session, fv.RateLimiter(QUOTA_PER_SECOND))
+    OUT.mkdir(parents=True, exist_ok=True)
+
+    done = {}
+    if os.path.exists(a.out):
+        try:
+            prev = json.load(open(a.out))
+            done = {(q["video"], q["chunk"]) for q in prev.get("questions", [])}
+            questions = prev.get("questions", [])
+            print(f"resuming: {len(questions)} questions over {len(done)} windows", flush=True)
+        except Exception:
+            questions = []
+    else:
+        questions = []
+    rows = [r for r in rows if (r["video"], r["chunk"]) not in done]
+    print(f"to do: {len(rows)} windows", flush=True)
+
+    lock = threading.Lock()
+    counter = {"n": 0}
+
+    def work(r):
+        vocab = scene_vocabulary(r["evidence"])
+        try:
+            data = gen.generate_valid_json(
+                api,
+                Q_PROMPT.format(n=a.n_per_window, vid=r["video"], t0=mmss(r["t0"]), t1=mmss(r["t1"]),
+                                evidence=json.dumps(r["evidence"], ensure_ascii=False),
+                                types=", ".join(TYPES)),
+                make_validator(a.n_per_window, r["t0"], r["t1"], vocab), 32768)
+        except Exception as exc:
+            return [], f"{type(exc).__name__}: {exc}"
+
+        out = []
+        for q in data["questions"]:
+            shuffle(q)
+            q.update({"video": r["video"], "chunk": r["chunk"], "window_sec": [r["t0"], r["t1"]],
+                      "clip": r["clip"]})
+            gates = {"structure": "pass", "leak_scan": "pass"}
+
+            arity = "Exactly three options are correct."
+            hits, guesses = 0, []
+            for t in range(3):
+                try:
+                    bg = gen.generate_valid_json(
+                        api, fv.BLIND_PROMPT.format(question=q["question"],
+                                                    options=json.dumps(q["options"], ensure_ascii=False),
+                                                    arity=f"{arity} (attempt {t + 1})"),
+                        fv.validate_blind, 4096)
+                    g = sorted(bg["answer"])
+                except Exception:
+                    g = ["?"]
+                guesses.append(g)
+                hits += g == sorted(q["answer"])
+            gates["blind_guess"] = {"guesses": guesses, "hits_of_3": hits, "matches_gold": hits >= 2}
+
+            if gates["blind_guess"]["matches_gold"]:
+                # Guessable without video; the re-check is the most expensive call in the
+                # pipeline and would only confirm a question already lost.
+                gates["visual_recheck"] = {"verdict": "skipped", "notes": "blind-guessable"}
+            elif not r["clip"]:
+                gates["visual_recheck"] = {"verdict": "skipped", "notes": "no clip on disk"}
+            else:
+                try:
+                    parts = [{"text": RECHECK_PROMPT.format(
+                                  question=q["question"],
+                                  options=json.dumps(q["options"], ensure_ascii=False),
+                                  answer=json.dumps(q["answer"]))},
+                             video_part(r["clip"])]
+                    gates["visual_recheck"] = gen.clean_json(
+                        api.generate(gen.CAPTION_MODEL, parts, 8192, json_mode=True))
+                    validate_verdict(gates["visual_recheck"])
+                except Exception as exc:
+                    gates["visual_recheck"] = {"verdict": "error", "notes": type(exc).__name__}
+            q["gates"] = gates
+            out.append(q)
+        return out, None
+
+    with concurrent.futures.ThreadPoolExecutor(max_workers=a.jobs) as pool:
+        for got, err in pool.map(work, rows):
+            with lock:
+                counter["n"] += 1
+                i = counter["n"]
+                if err:
+                    print(f"  !! window {i}: {err}", flush=True)
+                questions += got
+                usable = sum(1 for q in questions
+                             if q["gates"].get("visual_recheck", {}).get("verdict") == "supported"
+                             and not q["gates"]["blind_guess"].get("matches_gold"))
+                print(f"  {i}/{len(rows)} windows · {len(questions)} questions · {usable} usable", flush=True)
+                json.dump({"n": len(questions), "questions": questions},
+                          open(a.out, "w"), ensure_ascii=False, indent=1)
+
+    total = len(questions)
+    usable = [q for q in questions
+              if q["gates"].get("visual_recheck", {}).get("verdict") == "supported"
+              and not q["gates"]["blind_guess"].get("matches_gold")]
+    blind = sum(1 for q in questions if q["gates"]["blind_guess"].get("matches_gold"))
+    print(f"\n=== {total} questions from {len(rows)} windows -> {a.out}")
+    if total:
+        lo, hi = wilson(len(usable), total)
+        bl, bh = wilson(blind, total)
+        print(f"usable        {len(usable)}/{total} = {100*len(usable)/total:.1f}%  95% CI [{lo:.1f}, {hi:.1f}]")
+        print(f"blind-guessed {blind}/{total} = {100*blind/total:.1f}%  95% CI [{bl:.1f}, {bh:.1f}]")
+        print(f"  (segment corpus 48.6%, full-video 8-option multi 7.3%)")
+        by_v = collections.Counter()
+        for q in questions:
+            v = q["gates"].get("visual_recheck", {})
+            by_v[v.get("verdict") if isinstance(v, dict) else v] += 1
+        print(f"recheck       {dict(by_v)}")
+        by_t = collections.defaultdict(collections.Counter)
+        for q in questions:
+            ok = q in usable
+            by_t[q["question_type"]]["ok" if ok else "no"] += 1
+        for t, c in sorted(by_t.items()):
+            n = c["ok"] + c["no"]
+            print(f"  {t:26s} {c['ok']:3d}/{n:3d}  {100*c['ok']/n:3.0f}%")
+        if total < 100:
+            print(f"\nNOTE: n={total} is small. Distinguishing a ~7-point difference in guess rate "
+                  f"needs about 800 per group; read these intervals, not the point estimates.")
+
+
+if __name__ == "__main__":
+    sys.exit(main())

multi_video_cross_video_methodology/source_docs/expand_mcq.py

@@ -0,0 +1,435 @@
+#!/usr/bin/env python3
+"""Expand the RunningBench MCQ pool: more distractors per question, more questions per segment.
+
+Both modes are text-only — they read the existing `dense_annotations`; no video is
+decoded or uploaded. Output goes to a separate work directory and the source
+annotations are never modified.
+
+The Floodgate quota measured on this project is a hard 0.5 requests/second
+(30/min) regardless of concurrency, so the design minimises CALL COUNT rather
+than adding workers: every stage batches all of a segment's questions into one
+request, and a shared token bucket paces sending just under the quota so time is
+not wasted in 429 backoff.
+
+  --expand-options   pad every choice question up to the target option count,
+                     keeping only distractors a second pass judges to be
+                     contradicted by the evidence.
+  --more-questions   generate additional questions per segment, deliberately
+                     different in focus from the ones already present.
+
+Usage:
+  python3 expand_mcq.py --expand-options --more-questions --dry-run
+  python3 expand_mcq.py --expand-options --more-questions --pilot P01_SlowWalk_Day_Traj01
+  python3 expand_mcq.py --expand-options --more-questions
+"""
+import argparse, hashlib, importlib.util, json, os, random, sys, threading, time
+from collections import Counter
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+SEG_DIRS = [
+    Path("/mnt/data/data_anno/conductor_release/annotations_60s"),
+    Path("/mnt/data/data_anno/runningbench_gap_repair/annotations_60s"),
+]
+DEFAULT_WORK = Path("/mnt/data/data_anno/runningbench_qa_expansion")
+
+TARGET_SINGLE = 6                # A-F, random baseline 16.7%
+TARGET_MULTI = 8                 # A-H
+NEW_QUESTIONS_PER_SEGMENT = 3    # on top of the 3 already there
+QUOTA_PER_SECOND = 0.48          # measured ceiling is 0.50; stay just under it
+
+LEAK_PHRASES = (
+    "explicitly described", "as described", "described in the video", "described throughout",
+    "according to the description", "the description", "mentioned in", "stated in",
+    "the evidence", "the annotation", "based on the text", "the provided",
+)
+
+DISTRACTOR_PROMPT = """You are extending video-understanding benchmark questions with extra wrong options.
+
+EVIDENCE (the only ground truth; one segment of a first-person walking/running video):
+{evidence}
+
+For each question below, write exactly the requested number of NEW options. Every new option must be:
+- plausible for this kind of video, similar in length and style to the existing options;
+- DEFINITIVELY CONTRADICTED by the evidence above — never merely unmentioned, never partly true;
+- clearly distinct from every existing option and from your other new options.
+
+QUESTIONS:
+{questions}
+
+Return only a JSON object keyed by question id:
+{{"new_options": {{"q1": ["...", "..."], "q2": ["..."]}}}}"""
+
+VERIFY_PROMPT = """Judge each numbered statement against the evidence from a first-person video segment.
+
+EVIDENCE:
+{evidence}
+
+STATEMENTS:
+{statements}
+
+For each statement answer strictly:
+- "contradicted" if the evidence positively rules it out;
+- "supported" if the evidence indicates it is true;
+- "unclear" if the evidence neither confirms nor rules it out.
+
+Return only a JSON object with one verdict per statement, in the same order:
+{{"verdicts": ["contradicted", "unclear", ...]}}"""
+
+QUESTION_PROMPT = """Create exactly {count} NEW English benchmark questions from the evidence below.
+
+EVIDENCE (the only ground truth; one segment of a first-person walking/running video):
+{evidence}
+
+QUESTIONS ALREADY ASKED about this segment — yours must test something different:
+{existing}
+
+Return only a JSON object with the key `qa_pairs`. Every question must contain
+question, options, answer, is_multiple_choice and type.
+- `type` is one of trajectory-qa, visual-grounded-qa, spatial-temporal-reasoning.
+- `options` is a JSON OBJECT keyed by consecutive uppercase letters starting at A,
+  e.g. {{"A": "...", "B": "..."}} — not a list.
+- Exactly {n_single} questions are single choice with {target_single} options and exactly one answer.
+- The rest are multiple choice with {target_multi} options and at least two answers.
+- `answer` is a non-empty list of option letters.
+
+Use only the supplied evidence, but write every question as if asking someone who is
+WATCHING THE VIDEO and has never seen this text. Never refer to the evidence itself:
+no "as described", "explicitly described", "described in the video", "mentioned",
+"according to the description", "the evidence". Ask about what happens on screen.
+
+Distractors must be plausible but unambiguously false."""
+
+
+class RateLimiter:
+    """Shared token bucket: the server quota, not worker count, is the bottleneck."""
+
+    def __init__(self, per_second: float):
+        self.interval = 1.0 / per_second
+        self.lock = threading.Lock()
+        self.next_slot = time.monotonic()
+
+    def acquire(self) -> None:
+        with self.lock:
+            now = time.monotonic()
+            wait = max(0.0, self.next_slot - now)
+            self.next_slot = max(now, self.next_slot) + self.interval
+        if wait:
+            time.sleep(wait)
+
+
+class PacedSession:
+    """Wrap a requests.Session so the quota paces every outbound attempt.
+
+    Pacing only the logical call is not enough: generate() and
+    generate_valid_json() retry internally, and those retries would otherwise
+    bypass the limiter, hit 429 and burn 5-120s of backoff each.
+    """
+
+    def __init__(self, session, limiter):
+        self._session = session
+        self._limiter = limiter
+
+    def post(self, *args, **kwargs):
+        self._limiter.acquire()
+        return self._session.post(*args, **kwargs)
+
+    def __getattr__(self, name):
+        return getattr(self._session, name)
+
+
+def load_generator():
+    spec = importlib.util.spec_from_file_location(
+        "repair_runningbench_annotations", HERE / "repair_runningbench_annotations.py"
+    )
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+def shortfall_of(item) -> int:
+    options, answer = item.get("options"), item.get("answer") or []
+    if not isinstance(options, dict) or not options:
+        return 0
+    if sorted(options) != [chr(ord("A") + i) for i in range(len(options))]:
+        return 0                      # corrupted keys: leave alone
+    want = TARGET_MULTI if len(answer) > 1 else TARGET_SINGLE
+    return max(0, want - len(options))
+
+
+def make_distractor_validator(wanted: dict):
+    def validate(data):
+        block = data.get("new_options")
+        if not isinstance(block, dict):
+            raise ValueError("new_options must be an object keyed by question id")
+        for qid, count in wanted.items():
+            options = block.get(qid)
+            if not isinstance(options, list) or len(options) != count:
+                raise ValueError(f"{qid} needs exactly {count} new options")
+            if any(not isinstance(o, str) or not o.strip() for o in options):
+                raise ValueError(f"{qid} has an empty option")
+            if len({o.strip().lower() for o in options}) != count:
+                raise ValueError(f"{qid} has duplicate new options")
+    return validate
+
+
+def make_verdict_validator(count):
+    def validate(data):
+        verdicts = data.get("verdicts")
+        if not isinstance(verdicts, list) or len(verdicts) != count:
+            raise ValueError(f"verdicts must be a list of exactly {count} entries")
+        if any(v not in ("contradicted", "supported", "unclear") for v in verdicts):
+            raise ValueError("each verdict must be contradicted, supported or unclear")
+    return validate
+
+
+def make_question_validator(count):
+    def validate(data):
+        qa = data.get("qa_pairs")
+        if not isinstance(qa, list) or len(qa) != count:
+            raise ValueError(f"qa_pairs must contain exactly {count} questions")
+        for item in qa:
+            # The model reliably answers with a positional list of option strings
+            # rather than a letter-keyed object. Normalise instead of retrying:
+            # position already carries the letter, so the mapping is lossless.
+            if isinstance(item.get("options"), list) and all(
+                    isinstance(o, str) for o in item["options"]):
+                item["options"] = {chr(ord("A") + i): o for i, o in enumerate(item["options"])}
+            options, answer = item.get("options"), item.get("answer")
+            if not item.get("question"):
+                raise ValueError("question text is required")
+            if item.get("type") not in ("trajectory-qa", "visual-grounded-qa", "spatial-temporal-reasoning"):
+                raise ValueError("invalid type")
+            if not isinstance(options, dict):
+                raise ValueError("options must be an object")
+            if sorted(options) != [chr(ord("A") + i) for i in range(len(options))]:
+                raise ValueError("option keys must be consecutive from A")
+            if not isinstance(answer, list) or not answer or not set(answer) <= set(options):
+                raise ValueError("invalid answer")
+            item["is_multiple_choice"] = len(answer) > 1
+            want = TARGET_MULTI if len(answer) > 1 else TARGET_SINGLE
+            if len(options) != want:
+                raise ValueError(f"expected {want} options for this answer arity, got {len(options)}")
+            lowered = item["question"].lower()
+            leaked = [p for p in LEAK_PHRASES if p in lowered]
+            if leaked:
+                # Citing the description makes the question unanswerable from the video.
+                raise ValueError(f"question refers to the evidence text ({leaked[0]!r})")
+        if not any(len(i["answer"]) == 1 for i in qa):
+            raise ValueError("need at least one single-choice question")
+    return validate
+
+
+def reletter(item, texts, correct_texts, salt):
+    order = list(range(len(texts)))
+    seed = hashlib.sha256((item["question"] + salt).encode("utf-8")).hexdigest()
+    random.Random(seed).shuffle(order)
+    item["options"] = {chr(ord("A") + i): texts[j] for i, j in enumerate(order)}
+    item["answer"] = sorted(chr(ord("A") + i) for i, j in enumerate(order) if texts[j] in correct_texts)
+
+
+def collect(pilot):
+    out = []
+    for directory in SEG_DIRS:
+        for path in sorted(directory.glob("**/*_segment_*_annotation.json")):
+            if pilot and pilot not in path.name:
+                continue
+            try:
+                record = json.loads(path.read_text(encoding="utf-8"))
+            except Exception:
+                continue
+            if record.get("dense_annotations") and record.get("qa_pairs"):
+                out.append((path, record))
+    return out
+
+
+def target_dir(work, source: Path) -> Path:
+    tail = source.parts[source.parts.index("annotations_60s") + 1:]
+    return work.joinpath("annotations_60s", *tail)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--work", type=Path, default=DEFAULT_WORK)
+    parser.add_argument("--expand-options", action="store_true")
+    parser.add_argument("--more-questions", action="store_true")
+    parser.add_argument("--pilot")
+    parser.add_argument("--workers", type=int, default=3)
+    parser.add_argument("--rate", type=float, default=QUOTA_PER_SECOND)
+    parser.add_argument("--dry-run", action="store_true")
+    args = parser.parse_args()
+    if not (args.expand_options or args.more_questions):
+        raise SystemExit("pass --expand-options and/or --more-questions")
+
+    gen = load_generator()
+    records = collect(args.pilot)
+    calls = len(records) * ((2 if args.expand_options else 0) + (1 if args.more_questions else 0))
+    print(f"segments in scope: {len(records)}")
+    print(f"batched calls: {calls}  (~{calls / args.rate / 3600:.1f} h at {args.rate}/s)")
+    if args.dry_run:
+        return 0
+
+    token = os.environ.get("FLOODGATE_PROJECT_TOKEN")
+    if not token:
+        raise SystemExit("FLOODGATE_PROJECT_TOKEN is required")
+
+    limiter = RateLimiter(args.rate)
+    stats = Counter()
+    lock = threading.Lock()
+    local = threading.local()
+
+    def call(prompt, validator, max_tokens):
+        if not hasattr(local, "api"):
+            local.api = gen.Floodgate(token)   # requests.Session is not thread-safe
+            local.api.session = PacedSession(local.api.session, limiter)
+        return gen.generate_valid_json(local.api, prompt, validator, max_tokens)
+
+    def bump(key, amount=1):
+        with lock:
+            stats[key] += amount
+
+    def process(number, path, record):
+        out_path = target_dir(args.work, path)
+        if out_path.exists():
+            try:
+                if json.loads(out_path.read_text(encoding="utf-8")).get("expansion_complete"):
+                    bump("segments_skipped")
+                    return
+            except Exception:
+                pass
+        evidence = json.dumps(record["dense_annotations"], ensure_ascii=False)
+
+        if args.expand_options:
+            targets = {}
+            for index, item in enumerate(record["qa_pairs"], 1):
+                need = shortfall_of(item)
+                if need:
+                    targets[f"q{index}"] = (item, need)
+                elif isinstance(item.get("options"), dict):
+                    bump("questions_already_wide")
+            if targets:
+                listing = "\n\n".join(
+                    f"{qid} (needs {need} new options)\nQUESTION: {item['question']}\n"
+                    + "EXISTING OPTIONS (do not repeat or paraphrase):\n"
+                    + "\n".join(f"- {item['options'][k]}" for k in sorted(item["options"]))
+                    for qid, (item, need) in targets.items()
+                )
+                try:
+                    proposed = call(
+                        DISTRACTOR_PROMPT.format(evidence=evidence, questions=listing),
+                        make_distractor_validator({q: n for q, (_, n) in targets.items()}),
+                        4096)["new_options"]
+                except Exception as exc:
+                    proposed = None
+                    bump("distractor_call_failed")
+                    print(f"    distractor call failed {path.name}: {type(exc).__name__}", flush=True)
+
+                if proposed:
+                    flat = [(qid, text) for qid in targets for text in proposed[qid]]
+                    bump("distractors_proposed", len(flat))
+                    numbered = "\n".join(f"{i + 1}. {t}" for i, (_, t) in enumerate(flat))
+                    try:
+                        verdicts = call(
+                            VERIFY_PROMPT.format(evidence=evidence, statements=numbered),
+                            make_verdict_validator(len(flat)), 2048)["verdicts"]
+                    except Exception as exc:
+                        # Never promote an unverified distractor.
+                        verdicts = None
+                        bump("verify_call_failed")
+                        print(f"    verify call failed {path.name}: {type(exc).__name__}", flush=True)
+
+                    if verdicts:
+                        accepted = {qid: [] for qid in targets}
+                        for (qid, text), verdict in zip(flat, verdicts):
+                            bump(f"verdict_{verdict}")
+                            if verdict == "contradicted":
+                                accepted[qid].append(text)
+                        retry = {qid: need for qid, (item, need) in targets.items() if not accepted[qid]}
+                        if retry:
+                            # All candidates were rejected; ask once more before giving up.
+                            again = "\n\n".join(
+                                f"{qid} (needs {need} new options)\nQUESTION: {targets[qid][0]['question']}\n"
+                                + "EXISTING OPTIONS (do not repeat or paraphrase):\n"
+                                + "\n".join(f"- {targets[qid][0]['options'][k]}" for k in sorted(targets[qid][0]["options"]))
+                                for qid, need in retry.items())
+                            try:
+                                more = call(DISTRACTOR_PROMPT.format(evidence=evidence, questions=again),
+                                            make_distractor_validator(retry), 4096)["new_options"]
+                                flat2 = [(qid, t) for qid in retry for t in more[qid]]
+                                bump("distractors_proposed", len(flat2))
+                                v2 = call(VERIFY_PROMPT.format(
+                                    evidence=evidence,
+                                    statements="\n".join(f"{i + 1}. {t}" for i, (_, t) in enumerate(flat2))),
+                                    make_verdict_validator(len(flat2)), 2048)["verdicts"]
+                                for (qid, text), verdict in zip(flat2, v2):
+                                    bump(f"verdict_{verdict}")
+                                    if verdict == "contradicted":
+                                        accepted[qid].append(text)
+                                bump("second_round_used")
+                            except Exception as exc:
+                                bump("second_round_failed")
+                                print(f"    second widen round failed {path.name}: {type(exc).__name__}", flush=True)
+                        for qid, (item, _) in targets.items():
+                            if not accepted[qid]:
+                                bump("questions_not_widened")
+                                continue
+                            keys = sorted(item["options"])
+                            correct = {item["options"][k] for k in item["answer"]}
+                            texts = [item["options"][k] for k in keys] + accepted[qid]
+                            reletter(item, texts, correct, "|expanded")
+                            item["option_count_expanded_to"] = len(texts)
+                            bump("questions_widened")
+                            bump("distractors_added", len(accepted[qid]))
+
+        if args.more_questions:
+            count = NEW_QUESTIONS_PER_SEGMENT
+            asked = "\n".join(f"- {q['question']}" for q in record["qa_pairs"])
+            try:
+                extra = call(
+                    QUESTION_PROMPT.format(count=count, evidence=evidence, existing=asked,
+                                           n_single=count - count // 2,
+                                           target_single=TARGET_SINGLE, target_multi=TARGET_MULTI),
+                    make_question_validator(count), 8192)
+                # New questions come back with the correct option written first, like the
+                # originals did; shuffle them too or the 61% blind baseline returns.
+                gen.shuffle_options(extra["qa_pairs"])
+                for item in extra["qa_pairs"]:
+                    item["generated_by"] = "expand_mcq/more-questions"
+                    item["new_question_shuffled"] = True
+                record["qa_pairs"].extend(extra["qa_pairs"])
+                bump("questions_generated", len(extra["qa_pairs"]))
+            except Exception as exc:
+                bump("question_call_failed")
+                print(f"    question generation failed {path.name}: {type(exc).__name__}", flush=True)
+
+        record["option_order"] = "shuffled"
+        record["mcq_schema_version"] = "runningbench-mcq-v4-expanded"
+        record["expanded_from"] = str(path)
+        record["expansion_complete"] = True
+        record["expansion_spec"] = {
+            "target_single": TARGET_SINGLE, "target_multi": TARGET_MULTI,
+            "added_questions_per_segment": NEW_QUESTIONS_PER_SEGMENT if args.more_questions else 0,
+        }
+        gen.write_json(out_path, record)
+        bump("segments_written")
+        print(f"[{number}/{len(records)}] {path.name} -> {len(record['qa_pairs'])} questions", flush=True)
+
+    started = time.monotonic()
+    with ThreadPoolExecutor(max_workers=args.workers) as pool:
+        futures = {pool.submit(process, n, p, r): p for n, (p, r) in enumerate(records, 1)}
+        for future in as_completed(futures):
+            try:
+                future.result()
+            except Exception as exc:
+                bump("segments_failed")     # one bad segment must not end the run
+                print(f"    segment failed {futures[future].name}: {type(exc).__name__}: {exc}", flush=True)
+
+    print(f"\nelapsed {(time.monotonic() - started) / 60:.1f} min")
+    print(json.dumps(dict(sorted(stats.items())), indent=1))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

multi_video_cross_video_methodology/source_docs/export_segment_bundle.py

@@ -0,0 +1,134 @@
+#!/usr/bin/env python3
+"""Export the repaired segment questions plus their clips as one self-contained bundle.
+
+Only the distractor rebuild runs on the Gemini quota. The two gates that follow --
+blind-guess voting and the visual re-check -- are left for a local model, so this
+writes what those gates need and nothing else: one question per record, the 480p clip
+that shows it, and the evidence the answer came from.
+
+Gate order matters and is easy to get wrong. Shuffle BEFORE measuring guessability:
+generators favour putting the answer first and blind models favour picking first, so
+testing an unshuffled set reports a guess rate that is too high for the wrong reason.
+These questions are already shuffled (deterministically, seeded on the question text).
+
+Usage:  export_segment_bundle.py [--repaired pilot.json] [--out bundle/]
+"""
+import argparse
+import collections
+import glob
+import json
+import os
+import re
+import sys
+from pathlib import Path
+
+REPAIR_ROOT = Path("/mnt/data/data_anno/runningbench_segment_repair")
+CLIPS = REPAIR_ROOT / "clips_480p"
+SEG_ROOT = "/mnt/data/data_anno/runningbench_qa_expansion/annotations_60s"
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--repaired", default=str(REPAIR_ROOT / "repaired_all.json"))
+    ap.add_argument("--out", default=str(REPAIR_ROOT / "bundle"))
+    a = ap.parse_args()
+
+    out = Path(a.out)
+    out.mkdir(parents=True, exist_ok=True)
+    repaired = json.load(open(a.repaired))["repaired"]
+
+    # Segment metadata, keyed by the file the question came from.
+    meta = {}
+    for path in glob.glob(f"{SEG_ROOT}/**/*.json", recursive=True):
+        try:
+            rec = json.load(open(path))
+        except Exception:
+            continue
+        raw = rec.get("original_video_path") or ""
+        stem = re.sub(r"_segment_\d+$", "", os.path.basename(raw).rsplit(".", 1)[0])
+        meta[path] = {"video": stem, "segment_index": rec.get("segment_index"),
+                      "start_time_sec": rec.get("start_time_sec"),
+                      "end_time_sec": rec.get("end_time_sec"),
+                      "evidence": rec.get("dense_annotations") or rec.get("annotation_raw")}
+
+    rows, missing_clip = [], 0
+    for r in repaired:
+        m = meta.get(r["file"])
+        if not m:
+            continue
+        clip = CLIPS / m["video"] / f"{m['video']}_segment_{m['segment_index']}.480p.mp4"
+        if not clip.exists():
+            missing_clip += 1
+            clip = None
+        item = r["item"]
+        rows.append({
+            "id": f"{m['video']}_seg{m['segment_index']}_q{r['index']}",
+            "video": m["video"],
+            "segment_index": m["segment_index"],
+            "span_sec": [m["start_time_sec"], m["end_time_sec"]],
+            "clip": str(clip) if clip else None,
+            "question": item["question"],
+            "options": item["options"],
+            "answer": item["answer"],
+            "arity": "single" if len(item["answer"]) == 1 else "multi",
+            "type": item.get("type"),
+            "option_order": "shuffled",
+            "distractors_rebuilt": item.get("distractors_rebuilt", 0),
+            "evidence": m["evidence"],
+        })
+
+    json.dump({"n": len(rows),
+               "note": "distractors rebuilt with Gemini; blind-guess and visual re-check gates NOT run",
+               "questions": rows},
+              open(out / "questions.json", "w"), ensure_ascii=False, indent=1)
+
+    fmt = collections.Counter((r["arity"], len(r["options"])) for r in rows)
+    with open(out / "README.md", "w") as fh:
+        fh.write(f"""# 段级题修复包
+
+{len(rows)} 道题，干扰项已用 Gemini 重造并逐条验证「被证据明确否定」。
+**盲猜闸门和回看闸门都没跑** —— 留给本地模型。
+
+## 内容
+
+- `questions.json` — 每题一条记录，含 `clip` 指向该段的 480p 片段
+- 片段在 `{CLIPS}`，1,332 段，480p/crf30
+
+## 字段
+
+| 字段 | 说明 |
+|---|---|
+| `clip` | 该题对应的 60 秒片段路径，回看闸门用 |
+| `evidence` | 出题时用的结构化标注，验证干扰项用 |
+| `options` / `answer` | **已打乱**，answer 是字母列表 |
+| `distractors_rebuilt` | 本次重造并通过验证的干扰项个数 |
+
+## 建议的闸门顺序
+
+1. **盲猜 ×3**：只给 question + options，不给视频，答三次；≥2 次命中即淘汰
+2. **回看**：把 `clip` 和题目一起给模型，问画面是否支持 `answer`；只留 supported
+
+顺序不能颠倒 —— 选项已经打乱过了，直接跑盲猜即可。若你重新打乱，务必打乱后再测。
+
+## 已知基线（同一批语料，修复前）
+
+| | 可猜率 |
+|---|---|
+| 单选（主体 6 选项） | 64.7% |
+| 多选（主体 8 选项） | 25.3% |
+| 整体 | 48.6%（801 道抽样，95%CI [45.1, 52.0]） |
+
+修复后应显著低于这些数字，否则说明重造没起作用。
+
+## 格式分布
+
+""" + "\n".join(f"- {k[0]} {k[1]} 选项: {v}" for k, v in sorted(fmt.items())) + "\n")
+
+    print(f"wrote {len(rows)} questions -> {out}/questions.json")
+    print(f"  formats: {dict(fmt)}")
+    if missing_clip:
+        print(f"  WARNING: {missing_clip} questions have no clip on disk")
+
+
+if __name__ == "__main__":
+    sys.exit(main())

multi_video_cross_video_methodology/source_docs/package_full_release.py

@@ -0,0 +1,327 @@
+#!/usr/bin/env python3
+"""Package every question and caption in the corpus, both video sources, for human screening.
+
+An earlier package covered only the Google Drive subset, because the annotators were
+expected to have only that footage. The screening task is larger than that: of the 9,925
+questions that have never been judged, 5,324 come from HuggingFace recordings and
+Video Bench, so a Drive-only export hands the screeners under half of their own workload.
+
+Deduplication matters here and is easy to get wrong. The corpus keeps six older copies of
+the segment questions in separate directories -- conductor_release, gdrive_videos_annotations,
+shaky_videos_annotations, and others -- with 10,566 rows between them and not one question
+the current corpus lacks. Counting files instead of question texts inflates the total by
+2.5x. Rows are keyed on a hash of the question text, first writer wins, and the authoritative
+directory for each layer is listed first.
+
+Provenance also cannot be read from a path prefix. Mikail and Markus are HuggingFace
+subfolders whose older records still carry a /shaky_videos/ working-directory path, while
+`shaky_videos_segmented/` is where clips from EVERY source were written -- so matching on
+"shaky_videos" alone labels Google Drive recordings as HuggingFace. Only
+original_video_path decides, and the raw-vs-segmented distinction is explicit.
+
+Usage:  package_full_release.py [--out DIR]
+"""
+import argparse
+import collections
+import glob
+import hashlib
+import json
+import os
+import re
+import sys
+from pathlib import Path
+
+SCENES = "/mnt/data/cvhci_video_understanding/metadata/route_manifest/scene_manifest.json"
+DEFAULT_OUT = Path("/mnt/data/data_anno/runningbench_full_release")
+
+# Authoritative directory per layer, in priority order. Anything not listed is an older
+# copy: verified to contribute zero questions the current corpus does not already hold.
+CAPTION_SOURCES = [
+    ("segments_60s", ["/mnt/data/data_anno/runningbench_qa_expansion/annotations_60s/**/*.json",
+                      "/mnt/data/data_anno/runningbench_hf_gapfill/annotations_60s/**/*.json"]),
+    ("windows_180s", ["/mnt/data/data_anno/runningbench_gap_repair/annotations_180s/**/*.json"]),
+    ("windows_180s_aggregated",
+                     ["/mnt/data/data_anno/runningbench_aggregate_fill/annotations_180s/**/*.json"]),
+    ("whole_video",  ["/mnt/data/data_anno/runningbench_gap_repair/annotations_whole/**/*.json"]),
+    ("whole_video_aggregated",
+                     ["/mnt/data/data_anno/runningbench_aggregate_fill/annotations_whole/**/*.json"]),
+]
+
+
+def qhash(text):
+    return hashlib.sha256((text or "").strip().lower().encode("utf-8")).hexdigest()[:16]
+
+
+def gdrive_stems():
+    return {os.path.basename(r["file"]).rsplit(".", 1)[0]
+            for r in json.load(open(SCENES))["runs"] if "google_drive" in (r.get("file") or "")}
+
+
+def provenance(path):
+    """Google Drive or HuggingFace, from the ORIGINAL path only.
+
+    `/shaky_videos/Mikail/` is HuggingFace footage under its old working-directory path;
+    `/shaky_videos_segmented/` is the clip output directory shared by all sources and says
+    nothing about origin. Testing for "shaky_videos" without that distinction is what made
+    an earlier census report four sources where there are two.
+    """
+    if "google_drive" in path or "GDrive_Data" in path:
+        return "google_drive"
+    if "huggingface" in path.lower():
+        return "huggingface"
+    if re.search(r"/shaky_videos/(Mikail|Markus|Alec)/", path):
+        return "huggingface"
+    return "unknown"
+
+
+def load_items(path):
+    try:
+        doc = json.load(open(path))
+    except Exception:
+        return None, []
+    if not isinstance(doc, dict):
+        return None, []
+    items = []
+    for field in ("qa_pairs", "questions"):
+        v = doc.get(field)
+        if isinstance(v, list):
+            items += [x for x in v if isinstance(x, dict)]
+    return doc, items
+
+
+def is_objective(item):
+    opts = item.get("options") or item.get("choices")
+    ans = item.get("answer")
+    has = (isinstance(opts, dict) and opts) or (isinstance(opts, list) and opts)
+    return bool(has) and ans not in (None, "", [])
+
+
+def gate_status(item):
+    g = item.get("gates") or {}
+    if not g:
+        return "ungated", None, None
+    blind = bool((g.get("blind_guess") or {}).get("matches_gold"))
+    rc = g.get("visual_recheck") or {}
+    verdict = rc.get("verdict") if isinstance(rc, dict) else rc
+    if blind:
+        return "rejected_blind_guessable", verdict, (g.get("blind_guess") or {}).get("hits_of_3")
+    if verdict == "supported":
+        return "usable", verdict, (g.get("blind_guess") or {}).get("hits_of_3")
+    return f"rejected_{verdict}", verdict, (g.get("blind_guess") or {}).get("hits_of_3")
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--out", default=str(DEFAULT_OUT))
+    a = ap.parse_args()
+    out = Path(a.out)
+    gd = gdrive_stems()
+    seen = set()
+    stats = collections.OrderedDict()
+
+    def write(rel, rows):
+        p = out / rel
+        p.parent.mkdir(parents=True, exist_ok=True)
+        with open(p, "w") as fh:
+            for r in rows:
+                fh.write(json.dumps(r, ensure_ascii=False) + "\n")
+        stats[rel] = {"rows": len(rows), "bytes": p.stat().st_size}
+        return len(rows)
+
+    # ---------------- captions ----------------
+    for label, pats in CAPTION_SOURCES:
+        rows = []
+        for pat in pats:
+            for f in sorted(glob.glob(pat, recursive=True)):
+                doc, _ = load_items(f)
+                if not doc:
+                    continue
+                cap = doc.get("dense_annotations") or doc.get("annotation_raw")
+                if not cap:
+                    continue
+                src = doc.get("original_video_path") or ""
+                video = os.path.basename(src).rsplit(".", 1)[0]
+                idx = doc.get("segment_index", doc.get("chunk_index", 0))
+                key = (label, video, idx)
+                if key in seen:
+                    continue
+                seen.add(key)
+                rows.append({
+                    "id": f"{video}_{label}_{idx}", "video": video,
+                    "provenance": provenance(src), "index": idx,
+                    "span_sec": [doc.get("start_time_sec"), doc.get("end_time_sec")],
+                    "model": doc.get("model_name"),
+                    "aggregated_without_video": bool(doc.get("aggregated_without_video")),
+                    "derived_from": [os.path.basename(x) for x in (doc.get("derived_from") or [])],
+                    "caption": cap,
+                })
+        write(f"captions/{label}.jsonl", rows)
+
+    # whole-video structural annotations (the full-video line's own pass)
+    rows = []
+    for f in sorted(glob.glob("/mnt/data/data_anno/runningbench_fullvideo/**/annotations/*.json",
+                              recursive=True)):
+        rec = json.load(open(f))
+        stem = os.path.basename(f).rsplit(".", 1)[0]
+        rows.append({"id": stem, "video": stem,
+                     "provenance": "google_drive" if stem in gd else "huggingface",
+                     "scene_id": rec.get("scene_id"), "route_id": rec.get("route_id"),
+                     "duration_sec": rec.get("duration_sec"), "model": rec.get("global_model"),
+                     "run_meta": rec.get("run_meta"),
+                     "route_phases": rec.get("route_phases"),
+                     "environment_stages": rec.get("environment_stages"),
+                     "dynamic_events": rec.get("dynamic_events"),
+                     "revisited_landmarks": rec.get("revisited_landmarks"),
+                     "start_end_relation": rec.get("start_end_relation")})
+    write("captions/fullvideo_structural.jsonl", rows)
+
+    # ---------------- questions ----------------
+    qseen = set()
+    tally = collections.Counter()
+
+    def emit(item, doc, unit, layer, video_ids=None, forced_provenance=None):
+        h = qhash(item.get("question"))
+        if h in qseen:
+            return None
+        qseen.add(h)
+        opts = item.get("options") or item.get("choices")
+        ans = item.get("answer")
+        status, verdict, hits = gate_status(item)
+        src = (doc or {}).get("original_video_path") or ""
+        if video_ids:
+            prov = "google_drive" if all(v in gd for v in video_ids) else "huggingface"
+            video = video_ids if len(video_ids) > 1 else video_ids[0]
+        else:
+            prov = forced_provenance or provenance(src)
+            video = os.path.basename(src).rsplit(".", 1)[0] if src else None
+        n_ans = len(ans) if isinstance(ans, list) else 1
+        row = {
+            "id": h, "layer": layer, "unit": unit, "provenance": prov, "video": video,
+            "span_sec": [(doc or {}).get("start_time_sec"), (doc or {}).get("end_time_sec")],
+            "question": item.get("question"),
+            "question_type": item.get("question_type") or item.get("type"),
+            "options": opts, "answer": ans,
+            "arity": "multi" if n_ans > 1 else "single",
+            "n_options": len(opts) if isinstance(opts, (dict, list)) else None,
+            "option_order": item.get("option_order") or (doc or {}).get("option_order") or "unknown",
+            "evidence_spans": item.get("evidence_spans"),
+            "why_hard": item.get("why_hard"),
+            "screening_status": status,
+            "gates": ({"blind_guess_hits_of_3": hits, "visual_recheck": verdict,
+                       "recheck_notes": ((item.get("gates") or {}).get("visual_recheck") or {}).get("notes")
+                       if isinstance((item.get("gates") or {}).get("visual_recheck"), dict) else None}
+                      if item.get("gates") else None),
+        }
+        tally[(layer, status)] += 1
+        tally[(prov, "total")] += 1
+        return row
+
+    seg = []
+    for pat in ("/mnt/data/data_anno/runningbench_qa_expansion/annotations_60s/**/*.json",
+                "/mnt/data/data_anno/runningbench_hf_gapfill/annotations_60s/**/*.json"):
+        for f in sorted(glob.glob(pat, recursive=True)):
+            doc, items = load_items(f)
+            for it in items:
+                if not is_objective(it):
+                    continue
+                r = emit(it, doc, "60s_segment", "segment_60s")
+                if r:
+                    seg.append(r)
+    write("questions/segments_60s.jsonl", seg)
+
+    fv, cv = [], []
+    for f in sorted(glob.glob("/mnt/data/data_anno/runningbench_fullvideo/route_*/questions/*.json")):
+        doc, items = load_items(f)
+        for it in items:
+            if not is_objective(it):
+                continue
+            raw = it.get("video_id") or it.get("video_ids")
+            vids = ([raw] if isinstance(raw, str)
+                    else list(raw.values()) if isinstance(raw, dict) else list(raw or []))
+            if not vids:
+                continue
+            unit = "cross_video" if len(vids) > 1 else "whole_video"
+            r = emit(it, doc, unit, "fullvideo", vids)
+            if r:
+                r["video_ids"] = raw if isinstance(raw, dict) else None
+                (cv if unit == "cross_video" else fv).append(r)
+    write("questions/whole_video.jsonl", fv)
+    write("questions/cross_video.jsonl", cv)
+
+    exc = []
+    for f in sorted(glob.glob("/mnt/data/data_anno/runningbench_excerpts/fullvideo/*/questions/*.json")):
+        doc, items = load_items(f)
+        for it in items:
+            if not is_objective(it):
+                continue
+            raw = it.get("video_id") or it.get("video_ids")
+            vids = ([raw] if isinstance(raw, str)
+                    else list(raw.values()) if isinstance(raw, dict) else list(raw or []))
+            r = emit(it, doc, "excerpt", "excerpt", vids or None)
+            if r:
+                exc.append(r)
+    write("questions/excerpts.jsonl", exc)
+
+    vb = []
+    for pat in ("/mnt/data/data_anno/videobench_rebalanced/videobench_main.json",
+                "/mnt/data/data_anno/videobench_rebalanced/per_video/**/*.json"):
+        for f in sorted(glob.glob(pat, recursive=True)):
+            doc, items = load_items(f)
+            for it in items:
+                if not is_objective(it):
+                    continue
+                # Video Bench rows carry no original_video_path, so provenance() returns
+                # "unknown"; the footage is the HuggingFace set. Fix it before the tally
+                # counts it, not after -- the manifest reads the counter, not these rows.
+                r = emit(it, doc, "25s_segment", "videobench", forced_provenance="huggingface")
+                if r:
+                    r["family"] = it.get("family")
+                    r["difficulty"] = it.get("difficulty")
+                    r["answer_format"] = it.get("answer_format")
+                    vb.append(r)
+    write("questions/videobench.jsonl", vb)
+
+    # repaired distractors, kept apart: same questions, new options, never re-tested
+    rep = []
+    src = "/mnt/data/data_anno/runningbench_segment_repair/repaired_multi.json"
+    if os.path.exists(src):
+        for x in json.load(open(src))["repaired"]:
+            it = x["item"]
+            rep.append({"id": qhash(it.get("question")), "question": it.get("question"),
+                        "options": it.get("options"), "answer": it.get("answer"),
+                        "distractors_rebuilt": it.get("distractors_rebuilt", 0),
+                        "fully_reverted": it.get("distractors_rebuilt", 0) == 0,
+                        "screening_status": "ungated",
+                        "note": "distractors rebuilt from the text annotation; no video, no gates"})
+    write("questions/segments_60s_repaired_distractors.jsonl", rep)
+
+    total_q = len(seg) + len(fv) + len(cv) + len(exc) + len(vb)
+    by_status = collections.Counter()
+    for (layer, status), n in tally.items():
+        if status in ("total",):
+            continue
+        by_status[status] += n
+
+    manifest = {
+        "release": "runningbench-full-v1",
+        "sources": ["google_drive", "huggingface"],
+        "questions_total_deduplicated": total_q,
+        "by_status": dict(by_status),
+        "by_provenance": {k: v for (k, s), v in tally.items() if s == "total"},
+        "files": dict(stats),
+        "note": "Question rows are deduplicated on question text. Older duplicate copies of "
+                "the segment corpus (conductor_release, gdrive_videos_annotations, "
+                "shaky_videos_annotations*) contribute nothing and are excluded.",
+    }
+    (out / "manifest.json").write_text(json.dumps(manifest, ensure_ascii=False, indent=1))
+
+    print(f"{'file':52s} {'rows':>7s} {'size':>9s}")
+    for k, v in stats.items():
+        print(f"  {k:50s} {v['rows']:7d} {v['bytes']/2**20:8.2f}M")
+    print(f"\nquestions {total_q} · by status {dict(by_status)}")
+    print(f"by provenance {manifest['by_provenance']}")
+    print(f"-> {out}")
+
+
+if __name__ == "__main__":
+    sys.exit(main())

multi_video_cross_video_methodology/source_docs/package_gdrive_release.py

@@ -0,0 +1,240 @@
+#!/usr/bin/env python3
+"""Package the Google-Drive-sourced captions and QA pairs as one release directory.
+
+The corpus draws on four separate video sources -- a controlled Google Drive collection
+plus footage from HuggingFace and two contributors' folders -- and only the Drive subset
+carries the structural metadata (scene_id, route_id, turnaround_sec) that the route
+questions are built and checked against. This exports that subset alone, so a reader is
+never left guessing which rows have route metadata behind them and which do not.
+
+Provenance is taken from scene_manifest.json, not from filename shape: the run list there
+is the authority on which recording came from where, and inferring it from a "P01_" prefix
+would silently include or drop files the manifest disagrees with.
+
+Everything is written as JSONL, one record per line, so a 4,764-row question file can be
+streamed instead of loaded whole.
+
+Usage:  package_gdrive_release.py [--out DIR] [--copy-clips]
+"""
+import argparse
+import collections
+import json
+import glob
+import os
+import shutil
+import sys
+from pathlib import Path
+
+SCENES = "/mnt/data/cvhci_video_understanding/metadata/route_manifest/scene_manifest.json"
+SEG60 = "/mnt/data/data_anno/runningbench_qa_expansion/annotations_60s"
+GAP = "/mnt/data/data_anno/runningbench_gap_repair"
+FULL = "/mnt/data/data_anno/runningbench_fullvideo"
+DEFAULT_OUT = Path("/mnt/data/data_anno/runningbench_gdrive_release")
+
+
+def gdrive_runs():
+    """run_id -> run record, for the Google Drive subset only."""
+    out = {}
+    for r in json.load(open(SCENES))["runs"]:
+        if "google_drive" in (r.get("file") or ""):
+            out[os.path.basename(r["file"]).rsplit(".", 1)[0]] = r
+    return out
+
+
+def stem_of(rec):
+    p = rec.get("original_video_path") or rec.get("video_path") or ""
+    return os.path.basename(p).rsplit(".", 1)[0] if p else None
+
+
+def write_jsonl(path, rows):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with open(path, "w") as fh:
+        for r in rows:
+            fh.write(json.dumps(r, ensure_ascii=False) + "\n")
+    return len(rows), path.stat().st_size
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--out", default=str(DEFAULT_OUT))
+    ap.add_argument("--copy-clips", action="store_true",
+                    help="also copy the 480p re-check clips (adds several GiB)")
+    a = ap.parse_args()
+    out = Path(a.out)
+    runs = gdrive_runs()
+    print(f"Google Drive subset: {len(runs)} recordings", flush=True)
+
+    stats = collections.OrderedDict()
+
+    # ---- 60 s dense captions + their multiple-choice questions ----
+    cap60, qa60 = [], []
+    for f in sorted(glob.glob(f"{SEG60}/**/*.json", recursive=True)):
+        try:
+            rec = json.load(open(f))
+        except Exception:
+            continue
+        stem = stem_of(rec)
+        if stem not in runs:
+            continue
+        seg = rec.get("segment_index")
+        cap60.append({
+            "id": f"{stem}_seg{seg}",
+            "video": stem, "segment_index": seg,
+            "span_sec": [rec.get("start_time_sec"), rec.get("end_time_sec")],
+            "model": rec.get("model_name"),
+            "caption": rec.get("dense_annotations") or rec.get("annotation_raw"),
+        })
+        for i, item in enumerate(rec.get("qa_pairs") or []):
+            opts, ans = item.get("options"), item.get("answer")
+            if not (isinstance(opts, dict) and opts and isinstance(ans, list) and ans):
+                continue
+            qa60.append({
+                "id": f"{stem}_seg{seg}_q{i}",
+                "video": stem, "segment_index": seg,
+                "span_sec": [rec.get("start_time_sec"), rec.get("end_time_sec")],
+                "question": item.get("question"),
+                "options": opts, "answer": ans,
+                "arity": "single" if len(ans) == 1 else "multi",
+                "type": item.get("type"),
+                "option_order": rec.get("option_order", "unknown"),
+            })
+    stats["captions/segments_60s.jsonl"] = write_jsonl(out / "captions/segments_60s.jsonl", cap60)
+    stats["qa/segments_60s.jsonl"] = write_jsonl(out / "qa/segments_60s.jsonl", qa60)
+
+    # ---- 180 s windows and whole-video open-ended descriptions ----
+    for label, sub, gran in (("windows_180s", "annotations_180s", "180s"),
+                             ("whole_video", "annotations_whole", "whole")):
+        caps, qas = [], []
+        for f in sorted(glob.glob(f"{GAP}/{sub}/**/*.json", recursive=True)):
+            try:
+                rec = json.load(open(f))
+            except Exception:
+                continue
+            stem = stem_of(rec)
+            if stem not in runs:
+                continue
+            idx = rec.get("chunk_index", 0)
+            caps.append({
+                "id": f"{stem}_{gran}{idx}", "video": stem, "granularity": gran,
+                "chunk_index": idx,
+                "span_sec": [rec.get("start_time_sec"), rec.get("end_time_sec")],
+                "model": rec.get("model_name"),
+                "caption": rec.get("dense_annotations") or rec.get("annotation_raw"),
+                "derived_from_60s": [os.path.basename(x) for x in (rec.get("derived_from") or [])],
+            })
+            for i, item in enumerate(rec.get("qa_pairs") or []):
+                qas.append({
+                    "id": f"{stem}_{gran}{idx}_q{i}", "video": stem, "granularity": gran,
+                    "span_sec": [rec.get("start_time_sec"), rec.get("end_time_sec")],
+                    "question": item.get("question"),
+                    "answer": item.get("answer"),      # free text, no options
+                    "type": item.get("type"), "format": "open_ended",
+                })
+        stats[f"captions/{label}.jsonl"] = write_jsonl(out / f"captions/{label}.jsonl", caps)
+        stats[f"qa/{label}_open.jsonl"] = write_jsonl(out / f"qa/{label}_open.jsonl", qas)
+
+    # ---- whole-video structural annotations and their gated questions ----
+    fv_caps = []
+    for f in sorted(glob.glob(f"{FULL}/**/annotations/*.json", recursive=True)):
+        rec = json.load(open(f))
+        stem = os.path.basename(f).rsplit(".", 1)[0]
+        if stem not in runs:
+            continue
+        fv_caps.append({
+            "id": stem, "video": stem,
+            "scene_id": rec.get("scene_id"), "route_id": rec.get("route_id"),
+            "duration_sec": rec.get("duration_sec"),
+            "model": rec.get("global_model"),
+            "run_meta": rec.get("run_meta"),
+            "route_phases": rec.get("route_phases"),
+            "environment_stages": rec.get("environment_stages"),
+            "dynamic_events": rec.get("dynamic_events"),
+            "revisited_landmarks": rec.get("revisited_landmarks"),
+            "start_end_relation": rec.get("start_end_relation"),
+        })
+    stats["captions/fullvideo_structural.jsonl"] = write_jsonl(
+        out / "captions/fullvideo_structural.jsonl", fv_caps)
+
+    fv_qa = []
+    for f in sorted(glob.glob(f"{FULL}/**/questions/*.json", recursive=True)):
+        doc = json.load(open(f))
+        for q in doc.get("questions") or []:
+            # Whole-video questions carry `video_id`; cross-video ones carry `video_ids`
+            # (with `required_video_ids` alongside) and leave `video_id` null. Reading only
+            # the singular field silently drops every cross-video question -- all 347 of
+            # them -- which is the one part of this corpus nothing else replaces.
+            # Three shapes in one corpus. A whole-video question carries `video_id` as a
+            # string. A cross-video question leaves that null and carries `video_ids` as a
+            # LABEL->recording map ({"M": "P03_FastWalk_...", ...}) with `required_video_ids`
+            # listing the labels, not the recordings -- so reading either as a list of
+            # recordings yields label letters and matches nothing. Both earlier attempts
+            # dropped all 347 cross-video questions, the one part of this corpus that
+            # nothing else replaces.
+            raw = q.get("video_id") or q.get("video_ids")
+            if isinstance(raw, str):
+                vids, labels = [raw], None
+            elif isinstance(raw, dict):
+                vids, labels = list(raw.values()), raw
+            else:
+                vids, labels = list(raw or []), None
+            # A cross-video question belongs to the release only if every recording it
+            # compares is in the subset; a partial one cannot be answered from what ships.
+            if not vids or any(v not in runs for v in vids):
+                continue
+            g = q.get("gates") or {}
+            rc = g.get("visual_recheck")
+            verdict = rc.get("verdict") if isinstance(rc, dict) else rc
+            blind = bool((g.get("blind_guess") or {}).get("matches_gold"))
+            fv_qa.append({
+                "id": f"{'+'.join(vids)}_{abs(hash(q.get('question'))) % 10**8}",
+                "video_id": q.get("video_id"),
+                "video_ids": labels,
+                "scene_id": q.get("scene_id"), "route_id": q.get("route_id"),
+                "unit": "cross_video" if len(vids) > 1 else "whole_video",
+                "question": q.get("question"), "question_type": q.get("question_type"),
+                "options": q.get("options"), "answer": q.get("answer"),
+                "option_order": q.get("option_order"),
+                "evidence_spans": q.get("evidence_spans"),
+                "why_hard": q.get("why_hard"),
+                "gates": {"blind_guess_hits_of_3": (g.get("blind_guess") or {}).get("hits_of_3"),
+                          "blind_guessable": blind,
+                          "visual_recheck": verdict,
+                          "recheck_notes": rc.get("notes") if isinstance(rc, dict) else None},
+                "usable": verdict == "supported" and not blind,
+            })
+    stats["qa/fullvideo_gated.jsonl"] = write_jsonl(out / "qa/fullvideo_gated.jsonl", fv_qa)
+
+    if a.copy_clips:
+        dst = out / "clips_480p_180s"
+        n = 0
+        for src in glob.glob("/mnt/data/data_anno/runningbench_windows/clips_480p/**/*.mp4", recursive=True):
+            stem = os.path.basename(os.path.dirname(src))
+            if stem not in runs:
+                continue
+            (dst / stem).mkdir(parents=True, exist_ok=True)
+            shutil.copy2(src, dst / stem / os.path.basename(src))
+            n += 1
+        print(f"copied {n} clips", flush=True)
+
+    manifest = {
+        "release": "runningbench-gdrive-v1",
+        "source": "Google Drive controlled collection (scene_manifest.json subset)",
+        "recordings": len(runs),
+        "total_hours": round(sum(r.get("duration_sec") or 0 for r in runs.values()) / 3600, 2),
+        "participants": sorted({r.get("participant") for r in runs.values() if r.get("participant")}),
+        "files": {k: {"rows": v[0], "bytes": v[1]} for k, v in stats.items()},
+        "usable_fullvideo_questions": sum(1 for q in fv_qa if q["usable"]),
+    }
+    (out / "manifest.json").write_text(json.dumps(manifest, ensure_ascii=False, indent=1))
+
+    print(f"\n{'file':44s} {'rows':>7s} {'size':>10s}")
+    for k, (rows, size) in stats.items():
+        print(f"  {k:42s} {rows:7d} {size/2**20:9.2f}M")
+    print(f"\n{len(runs)} recordings · {manifest['total_hours']} h · "
+          f"participants {manifest['participants']}")
+    print(f"usable gated full-video questions: {manifest['usable_fullvideo_questions']}")
+    print(f"-> {out}")
+
+
+if __name__ == "__main__":
+    sys.exit(main())

multi_video_cross_video_methodology/source_docs/pilot_scripts_20260824/build_manifest.py

@@ -0,0 +1,135 @@
+#!/usr/bin/env python3
+"""Build a metadata manifest for the CVHCI running video collection."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+from collections import Counter
+from pathlib import Path
+
+import av
+
+
+NAME_RE = re.compile(
+    r"^(?P<participant>P\d{2})_"
+    r"(?P<activity>FastWalk|SlowWalk|Running)_"
+    r"(?P<lighting>Day|Night)_"
+    r"(?:(?:Traj(?P<trajectory>\d{2}))(?:_Trial(?P<trial_after_traj>\d{2}))?"
+    r"|(?:Trial(?P<trial>\d{2})))$"
+)
+
+
+def probe(path: Path) -> dict:
+    with av.open(str(path)) as container:
+        video = next((stream for stream in container.streams if stream.type == "video"), None)
+        audio = next((stream for stream in container.streams if stream.type == "audio"), None)
+        metadata_keys = {key.lower() for key in container.metadata}
+        return {
+            "duration_s": round(float(container.duration / av.time_base), 6)
+            if container.duration
+            else None,
+            "size_bytes": path.stat().st_size,
+            "bit_rate": container.bit_rate,
+            "video_codec": video.codec_context.name if video else None,
+            "width": video.codec_context.width if video else None,
+            "height": video.codec_context.height if video else None,
+            "fps": round(float(video.average_rate), 6)
+            if video and video.average_rate
+            else None,
+            "video_frames": video.frames if video else None,
+            "has_audio": audio is not None,
+            "audio_codec": audio.codec_context.name if audio else None,
+            "audio_sample_rate": audio.codec_context.sample_rate if audio else None,
+            "audio_channels": audio.codec_context.channels if audio else None,
+            # Record privacy-risk flags without copying sensitive values such
+            # as coordinates or capture timestamps into the derived manifest.
+            "has_location_metadata": any("location" in key for key in metadata_keys),
+            "has_creation_time_metadata": any("creation" in key for key in metadata_keys),
+            "stream_types": [stream.type for stream in container.streams],
+        }
+
+
+def parse_labels(path: Path) -> dict:
+    match = NAME_RE.fullmatch(path.stem)
+    if not match:
+        return {"parse_ok": False}
+    labels = match.groupdict()
+    trajectory = labels.pop("trajectory")
+    trial = labels.pop("trial")
+    trial_after_traj = labels.pop("trial_after_traj")
+    trial = trial or trial_after_traj
+    # The source naming is inconsistent: P01 uses Traj, P02 uses Trial, and
+    # P03 uses both. Preserve those semantics and expose only a neutral
+    # sequence index for balancing; do not assume that Trial means route.
+    sequence_index = int(trajectory or trial)
+    return {
+        "parse_ok": True,
+        **labels,
+        "trajectory_index": int(trajectory) if trajectory else None,
+        "trial_index": int(trial) if trial else None,
+        "sequence_index": sequence_index,
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("root", type=Path)
+    parser.add_argument("--output-dir", type=Path, required=True)
+    args = parser.parse_args()
+
+    paths = sorted(args.root.rglob("*.mp4"))
+    args.output_dir.mkdir(parents=True, exist_ok=True)
+    rows = []
+    failures = []
+    for path in paths:
+        relative_path = path.relative_to(args.root).as_posix()
+        row = {"id": path.stem, "relative_path": relative_path, **parse_labels(path)}
+        try:
+            row.update(probe(path))
+        except Exception as exc:  # Keep a manifest row for corrupt/partial files.
+            row["probe_error"] = f"{type(exc).__name__}: {exc}"
+            failures.append(relative_path)
+        rows.append(row)
+
+    manifest_path = args.output_dir / "manifest.jsonl"
+    with manifest_path.open("w", encoding="utf-8") as handle:
+        for row in rows:
+            handle.write(json.dumps(row, ensure_ascii=False, sort_keys=True) + "\n")
+
+    labeled = [row for row in rows if row.get("parse_ok")]
+    summary = {
+        "root": str(args.root.resolve()),
+        "video_count": len(rows),
+        "parse_failures": [row["relative_path"] for row in rows if not row.get("parse_ok")],
+        "probe_failures": failures,
+        "total_size_bytes": sum(row.get("size_bytes", 0) for row in rows),
+        "total_duration_s": round(sum(row.get("duration_s") or 0 for row in rows), 6),
+        "participants": dict(sorted(Counter(row["participant"] for row in labeled).items())),
+        "activities": dict(sorted(Counter(row["activity"] for row in labeled).items())),
+        "lighting": dict(sorted(Counter(row["lighting"] for row in labeled).items())),
+        "sequence_indices": dict(
+            sorted(Counter(str(row["sequence_index"]) for row in labeled).items())
+        ),
+        "codecs": dict(sorted(Counter(row.get("video_codec") for row in rows).items(), key=str)),
+        "resolutions": dict(
+            sorted(Counter(f"{row.get('width')}x{row.get('height')}" for row in rows).items())
+        ),
+        "videos_with_audio": sum(bool(row.get("has_audio")) for row in rows),
+        "videos_with_location_metadata": sum(
+            bool(row.get("has_location_metadata")) for row in rows
+        ),
+        "videos_with_creation_time_metadata": sum(
+            bool(row.get("has_creation_time_metadata")) for row in rows
+        ),
+    }
+    (args.output_dir / "summary.json").write_text(
+        json.dumps(summary, ensure_ascii=False, indent=2, sort_keys=True) + "\n",
+        encoding="utf-8",
+    )
+    print(json.dumps(summary, ensure_ascii=False, indent=2, sort_keys=True))
+
+
+if __name__ == "__main__":
+    main()

multi_video_cross_video_methodology/source_docs/pilot_scripts_20260824/download_gdrive_ranges.py

@@ -0,0 +1,143 @@
+#!/usr/bin/env python3
+"""Resume public Google Drive files through validated HTTP range requests.
+
+This is a fallback for large shared files when the normal download endpoint
+intermittently returns a quota HTML page. Chunks are accepted only when both
+HTTP Content-Range and byte length match the request.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import random
+import re
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+
+
+CHUNK_SIZE = 16 * 1024 * 1024
+CONTENT_RANGE_RE = re.compile(r"bytes (\d+)-(\d+)/(\d+)")
+
+
+def drive_id(url: str) -> str:
+    values = urllib.parse.parse_qs(urllib.parse.urlparse(url).query).get("id")
+    if not values:
+        raise ValueError(f"No id in URL: {url}")
+    return values[0]
+
+
+def request_range(file_id: str, start: int, end: int, attempts: int = 60) -> tuple[bytes, int]:
+    url = (
+        "https://drive.usercontent.google.com/download?"
+        + urllib.parse.urlencode({"id": file_id, "export": "download", "confirm": "t"})
+    )
+    expected = end - start + 1
+    last_error = "unknown"
+    for attempt in range(attempts):
+        request = urllib.request.Request(url, headers={"Range": f"bytes={start}-{end}"})
+        try:
+            with urllib.request.urlopen(request, timeout=90) as response:
+                data = response.read()
+                match = CONTENT_RANGE_RE.fullmatch(response.headers.get("Content-Range", ""))
+                if match:
+                    got_start, got_end, total = map(int, match.groups())
+                    if got_start == start and got_end == end and len(data) == expected:
+                        return data, total
+                last_error = (
+                    f"status={response.status} bytes={len(data)} "
+                    f"content_range={response.headers.get('Content-Range')}"
+                )
+        except (OSError, urllib.error.URLError) as exc:
+            last_error = f"{type(exc).__name__}: {exc}"
+        delay = min(2.0, 0.25 * (attempt + 1)) + random.random()
+        time.sleep(delay)
+    raise RuntimeError(f"range {start}-{end} failed after {attempts} attempts: {last_error}")
+
+
+def get_total(file_id: str) -> int:
+    _, total = request_range(file_id, 0, 0)
+    return total
+
+
+def save_state(path: Path, completed: set[int]) -> None:
+    temporary = path.with_suffix(path.suffix + ".tmp")
+    temporary.write_text(json.dumps(sorted(completed)) + "\n", encoding="utf-8")
+    os.replace(temporary, path)
+
+
+def download_one(root: Path, relative_path: str, file_id: str) -> str:
+    target = root / relative_path
+    target.parent.mkdir(parents=True, exist_ok=True)
+    total = get_total(file_id)
+    if target.exists() and target.stat().st_size == total:
+        return f"skip complete: {relative_path}"
+
+    part = target.with_suffix(target.suffix + ".part")
+    state = target.with_suffix(target.suffix + ".part.state.json")
+    if state.exists():
+        completed = set(json.loads(state.read_text(encoding="utf-8")))
+    else:
+        completed = set()
+        with part.open("wb") as handle:
+            handle.truncate(total)
+
+    chunk_count = (total + CHUNK_SIZE - 1) // CHUNK_SIZE
+    with part.open("r+b", buffering=0) as handle:
+        for index in range(chunk_count):
+            if index in completed:
+                continue
+            start = index * CHUNK_SIZE
+            end = min(total - 1, start + CHUNK_SIZE - 1)
+            data, reported_total = request_range(file_id, start, end)
+            if reported_total != total:
+                raise RuntimeError(
+                    f"size changed for {relative_path}: {total} -> {reported_total}"
+                )
+            handle.seek(start)
+            handle.write(data)
+            completed.add(index)
+            save_state(state, completed)
+            print(f"{relative_path}: {len(completed)}/{chunk_count} chunks", flush=True)
+        os.fsync(handle.fileno())
+
+    if part.stat().st_size != total or len(completed) != chunk_count:
+        raise RuntimeError(f"incomplete file: {relative_path}")
+    os.replace(part, target)
+    state.unlink(missing_ok=True)
+    return f"complete: {relative_path} ({total} bytes)"
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("listing", type=Path)
+    parser.add_argument("root", type=Path)
+    parser.add_argument("--workers", type=int, default=2)
+    args = parser.parse_args()
+
+    entries = json.loads(args.listing.read_text(encoding="utf-8"))
+    jobs = [(entry["path"], drive_id(entry["url"])) for entry in entries]
+    failures = []
+    with ThreadPoolExecutor(max_workers=args.workers) as executor:
+        futures = {
+            executor.submit(download_one, args.root, relative_path, file_id): relative_path
+            for relative_path, file_id in jobs
+        }
+        for future in as_completed(futures):
+            relative_path = futures[future]
+            try:
+                print(future.result(), flush=True)
+            except Exception as exc:
+                failures.append(relative_path)
+                print(f"FAILED {relative_path}: {exc}", flush=True)
+    if failures:
+        raise SystemExit(f"{len(failures)} downloads failed")
+
+
+if __name__ == "__main__":
+    main()

multi_video_cross_video_methodology/source_docs/pilot_scripts_20260824/make_contact_sheet.py

@@ -0,0 +1,59 @@
+#!/usr/bin/env python3
+"""Extract evenly spaced frames from one or more videos into a contact sheet."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+import av
+from PIL import Image, ImageDraw
+
+
+def sample_frames(path: Path, positions: tuple[float, ...]) -> list[tuple[float, Image.Image]]:
+    results = []
+    with av.open(str(path)) as container:
+        duration_s = float(container.duration / av.time_base)
+        stream = container.streams.video[0]
+        for position in positions:
+            target_s = duration_s * position
+            timestamp = int(target_s / float(stream.time_base))
+            container.seek(timestamp, stream=stream, backward=True)
+            frame = next(container.decode(stream))
+            results.append((target_s, frame.to_image()))
+    return results
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("videos", type=Path, nargs="+")
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument(
+        "--positions",
+        default="0.1,0.5,0.9",
+        help="Comma-separated relative positions from 0 to 1.",
+    )
+    args = parser.parse_args()
+
+    positions = tuple(float(value) for value in args.positions.split(","))
+    if not positions or any(value < 0 or value > 1 for value in positions):
+        raise ValueError("positions must be between 0 and 1")
+    tile_size = (480, 270)
+    label_height = 40
+    canvas = Image.new(
+        "RGB", (tile_size[0] * len(positions), (tile_size[1] + label_height) * len(args.videos)), "white"
+    )
+    draw = ImageDraw.Draw(canvas)
+    for row, path in enumerate(args.videos):
+        for column, (target_s, frame) in enumerate(sample_frames(path, positions)):
+            frame.thumbnail(tile_size)
+            x = column * tile_size[0]
+            y = row * (tile_size[1] + label_height)
+            canvas.paste(frame, (x, y))
+            draw.text((x + 6, y + tile_size[1] + 6), f"{path.name} @ {target_s:.1f}s", fill="black")
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    canvas.save(args.output, quality=90)
+
+
+if __name__ == "__main__":
+    main()

multi_video_cross_video_methodology/source_docs/repair_segment_distractors.py

@@ -0,0 +1,325 @@
+#!/usr/bin/env python3
+"""Rebuild segment-question distractors as near-misses, and measure whether it worked.
+
+A blind model scores 48.6% on this corpus (801-question sample, 95% CI [45.1, 52.0]),
+and 41.6% of the time it agrees with itself three times out of three. Reading the
+questions it beats shows two construction faults, both downstream of the original
+rule -- "DEFINITIVELY CONTRADICTED by the evidence":
+
+  1. The correct option is the most specific one. Distractors name generic props
+     ("a yellow school bus"), the answer reports what was actually seen ("a white van
+     among parked vehicles and a large dark trash dumpster"). Pick the longest, most
+     detailed option and you are usually right.
+  2. Distractors are impossible rather than merely false. Asked what signals the
+     wearer's movement, the wrong options offer engine noise and a dashboard view --
+     ruled out by knowing this is a first-person running video, no watching required.
+
+"Contradicted" guarantees an option is wrong. It does not guarantee it is tempting.
+So this regenerates distractors as near-misses of the answer itself -- same objects and
+actions, one attribute changed -- with the length band the full-video pipeline enforces
+(where the same blind test scores 7.3% on 8-option multi against this corpus's 27.8%).
+
+The gold option's text is never touched, only the distractors around it.
+
+Usage:  repair_segment_distractors.py --pilot 250      (repair, then blind-test)
+        repair_segment_distractors.py --all
+"""
+import argparse
+import collections
+import concurrent.futures
+import glob
+import hashlib
+import importlib.util
+import json
+import math
+import os
+import random
+import re
+import sys
+import threading
+from pathlib import Path
+
+BASE = Path("/mnt/task_runtime/bolt/gdrive_relay")
+SEG_ROOT = "/mnt/data/data_anno/runningbench_qa_expansion/annotations_60s"
+OUT = Path("/mnt/data/data_anno/runningbench_segment_repair")
+QUOTA_PER_SECOND = 0.45
+SEED = 20260831
+
+REPAIR_PROMPT = """Rewrite the WRONG options of one benchmark question about a 60-second first-person
+walking/running video. The correct option is fixed — never change, paraphrase or restate it.
+
+EVIDENCE (the only ground truth):
+{evidence}
+
+QUESTION: {question}
+CORRECT OPTION(S), verbatim and unchangeable:
+{correct}
+
+Write exactly {n} wrong options, and treat the whole SET as the thing you are designing.
+
+The trap to avoid, above everything else: if every wrong option is the correct one with a
+single detail edited, then on each detail the correct value is the majority value, and the
+answer can be recovered by taking the most common colour, the most common count, the most
+common side — no video needed. A set like this is worthless:
+
+    dark grey  / multi-story / glass        light yellow / single-story / glass
+    light yellow / multi-story / glass  <-- correct, and the majority on every axis
+    dark red   / multi-story / glass        light yellow / multi-story / wooden
+
+So:
+- Change TWO OR MORE details at once in most wrong options, and change different combinations
+  in different options. No detail of the correct option may appear in more than half the set.
+- Make the wrong options near-misses OF EACH OTHER too, not only of the correct one. A reader
+  who cannot see the video must find no option more "central" or more self-consistent than
+  the others.
+- Stay inside the world of this video. A wrong option that a person rules out just by knowing
+  this is a first-person walking/running recording is useless: no dashboards, no engine noise,
+  no indoor scenes unless the evidence has them.
+- Be CONTRADICTED by the evidence: it must positively rule the option out. Not merely
+  unmentioned, not partly true.
+- Match the correct option's specificity and length: between {lo} and {hi} characters, and the
+  correct option must not be the longest or the most detailed one in the set.
+
+Return only: {{"options": ["...", "..."]}}
+
+Each option is ONE plain string in that array. Do not prefix them with "-" or a bullet,
+do not put a newline inside one, and do not pack several options into a single string —
+returning the whole list as one item is the most common way this call fails."""
+
+VERIFY_PROMPT = """Judge each numbered statement against the evidence from a first-person video segment.
+
+EVIDENCE:
+{evidence}
+
+STATEMENTS:
+{statements}
+
+Answer strictly per statement:
+- "contradicted" if the evidence positively rules it out;
+- "supported" if the evidence indicates it is true;
+- "unclear" if the evidence neither confirms nor rules it out.
+
+Return only: {{"verdicts": ["contradicted", "unclear", ...]}}"""
+
+
+def wilson(k, n, z=1.96):
+    if not n:
+        return (0.0, 0.0)
+    p = k / n
+    d = 1 + z * z / n
+    c = p + z * z / (2 * n)
+    h = z * math.sqrt(p * (1 - p) / n + z * z / (4 * n * n))
+    return (100 * (c - h) / d, 100 * (c + h) / d)
+
+
+def load(name, path):
+    spec = importlib.util.spec_from_file_location(name, path)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+def clean_option(o):
+    """Strip a markdown bullet if the model wrapped its list items in one."""
+    return re.sub(r"^\s*[-*\u2022]\s+", "", o).strip() if isinstance(o, str) else o
+
+
+def make_repair_validator(n, lo, hi, correct):
+    gold = {c.strip().lower() for c in correct}
+
+    def check(d):
+        opts = d.get("options")
+        if not isinstance(opts, list) or len(opts) != n:
+            raise ValueError(f"need exactly {n} options, got {len(opts) if isinstance(opts, list) else '?'}")
+        # Normalise in place so the caller sees cleaned text, not the bulleted form.
+        d["options"] = opts = [clean_option(o) for o in opts]
+        seen = set()
+        for o in opts:
+            if not isinstance(o, str) or not o.strip():
+                raise ValueError("options must be non-empty strings")
+            if "\n" in o:
+                raise ValueError("one option per string; this one contains a newline")
+            key = o.strip().lower()
+            if key in gold:
+                raise ValueError("a wrong option repeats the correct option")
+            if key in seen:
+                raise ValueError("duplicate options")
+            seen.add(key)
+            if not (lo * 0.8 <= len(o) <= hi * 1.25):
+                raise ValueError(f"option length {len(o)} outside {int(lo)}..{int(hi)}: {o[:40]!r}")
+    return check
+
+
+def make_verdict_validator(n):
+    def check(d):
+        v = d.get("verdicts")
+        if not isinstance(v, list) or len(v) != n:
+            raise ValueError(f"need {n} verdicts")
+        for x in v:
+            if x not in ("contradicted", "supported", "unclear"):
+                raise ValueError(f"bad verdict {x!r}")
+    return check
+
+
+def shuffle(item):
+    keys = sorted(item["options"])
+    texts = [item["options"][k] for k in keys]
+    correct = {keys.index(k) for k in item["answer"]}
+    order = list(range(len(texts)))
+    random.Random(hashlib.sha256(item["question"].encode("utf-8")).hexdigest()).shuffle(order)
+    item["options"] = {chr(ord("A") + i): texts[src] for i, src in enumerate(order)}
+    item["answer"] = sorted(chr(ord("A") + i) for i, src in enumerate(order) if src in correct)
+
+
+def collect():
+    rows = []
+    for path in sorted(glob.glob(f"{SEG_ROOT}/**/*.json", recursive=True)):
+        try:
+            rec = json.load(open(path))
+        except Exception:
+            continue
+        ev = rec.get("dense_annotations") or rec.get("annotation_raw")
+        for idx, item in enumerate(rec.get("qa_pairs") or []):
+            o, a = item.get("options"), item.get("answer")
+            if isinstance(o, dict) and o and isinstance(a, list) and a:
+                rows.append({"file": path, "index": idx, "evidence": ev, "item": item})
+    return rows
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--pilot", type=int, default=0, help="repair a stratified sample and blind-test it")
+    ap.add_argument("--all", action="store_true")
+    ap.add_argument("--multi-only", action="store_true",
+                    help="repair only multi-answer questions. Single-choice sits at 65.2%% blind "
+                         "before repair and 54.5%% after, so rebuilding it buys a corpus that is "
+                         "still unusable; multi-answer runs 27.8%% -> 21.1%% from a far better start.")
+    ap.add_argument("--no-blind", action="store_true", help="repair only; leave the gates to a local model")
+    # A repair call takes ~11 s, so one worker issues only ~0.13 req/s against a 0.45 req/s
+    # quota -- the run is latency-bound, not quota-bound. Three workers fill the quota
+    # without exceeding it; the shared RateLimiter still serialises every attempt.
+    ap.add_argument("--jobs", type=int, default=3)
+    ap.add_argument("--out", default=str(OUT / "pilot.json"))
+    a = ap.parse_args()
+    if not (a.pilot or a.all):
+        ap.error("pass --pilot N or --all")
+
+    fv = load("fv", BASE / "build_fullvideo_annotations.py")
+    gen = load("gen", BASE / "repair_runningbench_annotations.py")
+
+    rows = collect()
+    print(f"corpus: {len(rows)} objective questions", flush=True)
+    if a.multi_only:
+        rows = [r for r in rows if len(r["item"]["answer"]) > 1]
+        print(f"multi-answer only: {len(rows)}", flush=True)
+    rng = random.Random(SEED)
+    if a.pilot:
+        strata = collections.defaultdict(list)
+        for r in rows:
+            strata[(len(r["item"]["options"]), len(r["item"]["answer"]) > 1)].append(r)
+        sample = []
+        for key, group in sorted(strata.items()):
+            take = max(1, round(a.pilot * len(group) / len(rows)))
+            rng.shuffle(group)
+            sample += group[:take]
+        rng.shuffle(sample)
+        rows = sample
+        print(f"pilot sample: {len(rows)}", flush=True)
+
+    api = gen.Floodgate("")
+    api.session = fv.PacedSession(api.session, fv.RateLimiter(QUOTA_PER_SECOND))
+
+    OUT.mkdir(parents=True, exist_ok=True)
+    repaired, results = [], []
+    # Resume: a 4-hour run should not restart from zero after an interruption.
+    done_keys = set()
+    if os.path.exists(a.out):
+        try:
+            prev = json.load(open(a.out))
+            repaired = prev.get("repaired", [])
+            results = prev.get("blind", [])
+            done_keys = {(r["file"], r["index"]) for r in repaired}
+            print(f"resuming: {len(done_keys)} already repaired", flush=True)
+        except Exception:
+            print("could not read previous output; starting fresh", flush=True)
+    rows = [r for r in rows if (r["file"], r["index"]) not in done_keys]
+    print(f"to do: {len(rows)}", flush=True)
+
+    lock = threading.Lock()
+    counter = {"n": 0}
+
+    def work(r):
+        item = json.loads(json.dumps(r["item"]))
+        keys = sorted(item["options"])
+        # One question in 8,148 has an answer letter with no matching option -- the
+        # generator emitted a literal "..." as an option key. Skip it rather than take
+        # the whole run down; a KeyError inside a pool worker kills every other thread.
+        absent = [k for k in item["answer"] if k not in item["options"]]
+        if absent:
+            return None, f"malformed: answer {absent} has no option (keys={keys})"
+        correct = [item["options"][k] for k in item["answer"]]
+        wrong_n = len(keys) - len(correct)
+        clen = [len(c) for c in correct]
+        lo, hi = min(clen) * 0.75, max(clen) * 1.05
+        try:
+            data = gen.generate_valid_json(
+                api,
+                REPAIR_PROMPT.format(evidence=json.dumps(r["evidence"], ensure_ascii=False),
+                                     question=item["question"],
+                                     correct="\n".join(f"- {c}" for c in correct),
+                                     n=wrong_n, lo=int(lo), hi=int(hi)),
+                make_repair_validator(wrong_n, lo, hi, correct), 8192)
+            new_wrong = data["options"]
+            verdicts = gen.generate_valid_json(
+                api,
+                VERIFY_PROMPT.format(evidence=json.dumps(r["evidence"], ensure_ascii=False),
+                                     statements="\n".join(f"{j+1}. {o}" for j, o in enumerate(new_wrong))),
+                make_verdict_validator(wrong_n), 4096)["verdicts"]
+        except Exception as exc:
+            return None, f"{type(exc).__name__}: {exc}"
+        # Keep only distractors the evidence positively rules out; fall back to the
+        # original wording for the rest rather than shipping an unverified option.
+        old_wrong = [item["options"][k] for k in keys if k not in item["answer"]]
+        kept = [o for o, v in zip(new_wrong, verdicts) if v == "contradicted"]
+        final_wrong = kept + old_wrong[len(kept):]
+        texts = correct + final_wrong
+        item["options"] = {chr(ord("A") + j): t for j, t in enumerate(texts)}
+        item["answer"] = [chr(ord("A") + j) for j in range(len(correct))]
+        shuffle(item)
+        item["distractors_rebuilt"] = len(kept)
+        if {item["options"][k] for k in item["answer"]} != set(correct):
+            return None, "gold text changed"
+        return {"file": r["file"], "index": r["index"], "item": item}, None
+
+    with concurrent.futures.ThreadPoolExecutor(max_workers=a.jobs) as pool:
+        for out_row, err in pool.map(work, rows):
+            with lock:
+                counter["n"] += 1
+                i = counter["n"]
+                if err:
+                    print(f"  !! {i}: {err}", flush=True)
+                else:
+                    repaired.append(out_row)
+                if i % 20 == 0 or i == len(rows):
+                    print(f"  {i}/{len(rows)} repaired {len(repaired)}", flush=True)
+                    json.dump({"repaired": repaired, "blind": results},
+                              open(a.out, "w"), ensure_ascii=False)
+
+    json.dump({"repaired": repaired, "blind": results}, open(a.out, "w"), ensure_ascii=False)
+    print(f"\nrepaired {len(repaired)}/{len(rows)}  ->  {a.out}")
+    if results:
+        k, n = sum(1 for x in results if x["guessable"]), len(results)
+        lo, hi = wilson(k, n)
+        print(f"\n=== blind-guess after repair ===")
+        print(f"overall  {k}/{n} = {100*k/n:.1f}%   95% CI [{lo:.1f}, {hi:.1f}]   (before: 48.6% [45.1, 52.0])")
+        for key, label in (((6, False), "6-option single"), ((8, True), "8-option multi")):
+            s = [x for x in results if (x["n_opt"], x["n_ans"] > 1) == key]
+            if s:
+                kk = sum(1 for x in s if x["guessable"])
+                l, h = wilson(kk, len(s))
+                print(f"{label:18s}{kk}/{len(s)} = {100*kk/len(s):.1f}%  [{l:.1f}, {h:.1f}]")
+        print("before: 6-option single 65.2%, 8-option multi 27.8%")
+
+
+if __name__ == "__main__":
+    sys.exit(main())